1 SINGLE_LINE_COMMENT -> // [1:0]
2 `--COMMENT_CONTENT -> //////////////////////////////////////////////////////////////////////////////\n [1:2]
3 SINGLE_LINE_COMMENT -> // [2:0]
4 `--COMMENT_CONTENT -> checkstyle: Checks Java source code for adherence to a set of rules.\n [2:2]
5 SINGLE_LINE_COMMENT -> // [3:0]
6 `--COMMENT_CONTENT -> Copyright (C) 2001-2021 the original author or authors.\n [3:2]
7 SINGLE_LINE_COMMENT -> // [4:0]
8 `--COMMENT_CONTENT -> \n [4:2]
9 SINGLE_LINE_COMMENT -> // [5:0]
10 `--COMMENT_CONTENT -> This library is free software; you can redistribute it and/or\n [5:2]
11 SINGLE_LINE_COMMENT -> // [6:0]
12 `--COMMENT_CONTENT -> modify it under the terms of the GNU Lesser General Public\n [6:2]
13 SINGLE_LINE_COMMENT -> // [7:0]
14 `--COMMENT_CONTENT -> License as published by the Free Software Foundation; either\n [7:2]
15 SINGLE_LINE_COMMENT -> // [8:0]
16 `--COMMENT_CONTENT -> version 2.1 of the License, or (at your option) any later version.\n [8:2]
17 SINGLE_LINE_COMMENT -> // [9:0]
18 `--COMMENT_CONTENT -> \n [9:2]
19 SINGLE_LINE_COMMENT -> // [10:0]
20 `--COMMENT_CONTENT -> This library is distributed in the hope that it will be useful,\n [10:2]
21 SINGLE_LINE_COMMENT -> // [11:0]
22 `--COMMENT_CONTENT -> but WITHOUT ANY WARRANTY; without even the implied warranty of\n [11:2]
23 SINGLE_LINE_COMMENT -> // [12:0]
24 `--COMMENT_CONTENT -> MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n [12:2]
25 SINGLE_LINE_COMMENT -> // [13:0]
26 `--COMMENT_CONTENT -> Lesser General Public License for more details.\n [13:2]
27 SINGLE_LINE_COMMENT -> // [14:0]
28 `--COMMENT_CONTENT -> \n [14:2]
29 SINGLE_LINE_COMMENT -> // [15:0]
30 `--COMMENT_CONTENT -> You should have received a copy of the GNU Lesser General Public\n [15:2]
31 SINGLE_LINE_COMMENT -> // [16:0]
32 `--COMMENT_CONTENT -> License along with this library; if not, write to the Free Software\n [16:2]
33 SINGLE_LINE_COMMENT -> // [17:0]
34 `--COMMENT_CONTENT -> Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n [17:2]
35 SINGLE_LINE_COMMENT -> // [18:0]
36 `--COMMENT_CONTENT -> //////////////////////////////////////////////////////////////////////////////\n [18:2]
37 PACKAGE_DEF -> package [20:0]
38 |--ANNOTATIONS -> ANNOTATIONS [20:46]
39 |--DOT -> . [20:46]
40 | |--DOT -> . [20:39]
41 | | |--DOT -> . [20:28]
42 | | | |--DOT -> . [20:22]
43 | | | | |--DOT -> . [20:11]
44 | | | | | |--IDENT -> com [20:8]
45 | | | | | `--IDENT -> puppycrawl [20:12]
46 | | | | `--IDENT -> tools [20:23]
47 | | | `--IDENT -> checkstyle [20:29]
48 | | `--IDENT -> checks [20:40]
49 | `--IDENT -> indentation [20:47]
50 `--SEMI -> ; [20:58]
51 STATIC_IMPORT -> import [22:0]
52 |--LITERAL_STATIC -> static [22:7]
53 |--DOT -> . [22:81]
54 | |--DOT -> . [22:64]
55 | | |--DOT -> . [22:52]
56 | | | |--DOT -> . [22:45]
57 | | | | |--DOT -> . [22:34]
58 | | | | | |--DOT -> . [22:28]
59 | | | | | | |--DOT -> . [22:17]
60 | | | | | | | |--IDENT -> com [22:14]
61 | | | | | | | `--IDENT -> puppycrawl [22:18]
62 | | | | | | `--IDENT -> tools [22:29]
63 | | | | | `--IDENT -> checkstyle [22:35]
64 | | | | `--IDENT -> checks [22:46]
65 | | | `--IDENT -> indentation [22:53]
66 | | `--IDENT -> IndentationCheck [22:65]
67 | `--IDENT -> MSG_CHILD_ERROR [22:82]
68 `--SEMI -> ; [22:97]
69 STATIC_IMPORT -> import [23:0]
70 |--LITERAL_STATIC -> static [23:7]
71 |--DOT -> . [23:81]
72 | |--DOT -> . [23:64]
73 | | |--DOT -> . [23:52]
74 | | | |--DOT -> . [23:45]
75 | | | | |--DOT -> . [23:34]
76 | | | | | |--DOT -> . [23:28]
77 | | | | | | |--DOT -> . [23:17]
78 | | | | | | | |--IDENT -> com [23:14]
79 | | | | | | | `--IDENT -> puppycrawl [23:18]
80 | | | | | | `--IDENT -> tools [23:29]
81 | | | | | `--IDENT -> checkstyle [23:35]
82 | | | | `--IDENT -> checks [23:46]
83 | | | `--IDENT -> indentation [23:53]
84 | | `--IDENT -> IndentationCheck [23:65]
85 | `--IDENT -> MSG_CHILD_ERROR_MULTI [23:82]
86 `--SEMI -> ; [23:103]
87 STATIC_IMPORT -> import [24:0]
88 |--LITERAL_STATIC -> static [24:7]
89 |--DOT -> . [24:81]
90 | |--DOT -> . [24:64]
91 | | |--DOT -> . [24:52]
92 | | | |--DOT -> . [24:45]
93 | | | | |--DOT -> . [24:34]
94 | | | | | |--DOT -> . [24:28]
95 | | | | | | |--DOT -> . [24:17]
96 | | | | | | | |--IDENT -> com [24:14]
97 | | | | | | | `--IDENT -> puppycrawl [24:18]
98 | | | | | | `--IDENT -> tools [24:29]
99 | | | | | `--IDENT -> checkstyle [24:35]
100 | | | | `--IDENT -> checks [24:46]
101 | | | `--IDENT -> indentation [24:53]
102 | | `--IDENT -> IndentationCheck [24:65]
103 | `--IDENT -> MSG_ERROR [24:82]
104 `--SEMI -> ; [24:91]
105 STATIC_IMPORT -> import [25:0]
106 |--LITERAL_STATIC -> static [25:7]
107 |--DOT -> . [25:81]
108 | |--DOT -> . [25:64]
109 | | |--DOT -> . [25:52]
110 | | | |--DOT -> . [25:45]
111 | | | | |--DOT -> . [25:34]
112 | | | | | |--DOT -> . [25:28]
113 | | | | | | |--DOT -> . [25:17]
114 | | | | | | | |--IDENT -> com [25:14]
115 | | | | | | | `--IDENT -> puppycrawl [25:18]
116 | | | | | | `--IDENT -> tools [25:29]
117 | | | | | `--IDENT -> checkstyle [25:35]
118 | | | | `--IDENT -> checks [25:46]
119 | | | `--IDENT -> indentation [25:53]
120 | | `--IDENT -> IndentationCheck [25:65]
121 | `--IDENT -> MSG_ERROR_MULTI [25:82]
122 `--SEMI -> ; [25:97]
123 STATIC_IMPORT -> import [26:0]
124 |--LITERAL_STATIC -> static [26:7]
125 |--DOT -> . [26:46]
126 | |--DOT -> . [26:35]
127 | | |--DOT -> . [26:31]
128 | | | |--DOT -> . [26:23]
129 | | | | |--DOT -> . [26:17]
130 | | | | | |--IDENT -> org [26:14]
131 | | | | | `--IDENT -> junit [26:18]
132 | | | | `--IDENT -> jupiter [26:24]
133 | | | `--IDENT -> api [26:32]
134 | | `--IDENT -> Assertions [26:36]
135 | `--IDENT -> assertArrayEquals [26:47]
136 `--SEMI -> ; [26:64]
137 STATIC_IMPORT -> import [27:0]
138 |--LITERAL_STATIC -> static [27:7]
139 |--DOT -> . [27:46]
140 | |--DOT -> . [27:35]
141 | | |--DOT -> . [27:31]
142 | | | |--DOT -> . [27:23]
143 | | | | |--DOT -> . [27:17]
144 | | | | | |--IDENT -> org [27:14]
145 | | | | | `--IDENT -> junit [27:18]
146 | | | | `--IDENT -> jupiter [27:24]
147 | | | `--IDENT -> api [27:32]
148 | | `--IDENT -> Assertions [27:36]
149 | `--IDENT -> assertEquals [27:47]
150 `--SEMI -> ; [27:59]
151 STATIC_IMPORT -> import [28:0]
152 |--LITERAL_STATIC -> static [28:7]
153 |--DOT -> . [28:46]
154 | |--DOT -> . [28:35]
155 | | |--DOT -> . [28:31]
156 | | | |--DOT -> . [28:23]
157 | | | | |--DOT -> . [28:17]
158 | | | | | |--IDENT -> org [28:14]
159 | | | | | `--IDENT -> junit [28:18]
160 | | | | `--IDENT -> jupiter [28:24]
161 | | | `--IDENT -> api [28:32]
162 | | `--IDENT -> Assertions [28:36]
163 | `--IDENT -> assertTrue [28:47]
164 `--SEMI -> ; [28:57]
165 STATIC_IMPORT -> import [29:0]
166 |--LITERAL_STATIC -> static [29:7]
167 |--DOT -> . [29:46]
168 | |--DOT -> . [29:35]
169 | | |--DOT -> . [29:31]
170 | | | |--DOT -> . [29:23]
171 | | | | |--DOT -> . [29:17]
172 | | | | | |--IDENT -> org [29:14]
173 | | | | | `--IDENT -> junit [29:18]
174 | | | | `--IDENT -> jupiter [29:24]
175 | | | `--IDENT -> api [29:32]
176 | | `--IDENT -> Assertions [29:36]
177 | `--IDENT -> fail [29:47]
178 `--SEMI -> ; [29:51]
179 IMPORT -> import [31:0]
180 |--DOT -> . [31:14]
181 | |--DOT -> . [31:11]
182 | | |--IDENT -> java [31:7]
183 | | `--IDENT -> io [31:12]
184 | `--IDENT -> BufferedReader [31:15]
185 `--SEMI -> ; [31:29]
186 IMPORT -> import [32:0]
187 |--DOT -> . [32:14]
188 | |--DOT -> . [32:11]
189 | | |--IDENT -> java [32:7]
190 | | `--IDENT -> io [32:12]
191 | `--IDENT -> IOException [32:15]
192 `--SEMI -> ; [32:26]
193 IMPORT -> import [33:0]
194 |--DOT -> . [33:23]
195 | |--DOT -> . [33:15]
196 | | |--DOT -> . [33:11]
197 | | | |--IDENT -> java [33:7]
198 | | | `--IDENT -> nio [33:12]
199 | | `--IDENT -> charset [33:16]
200 | `--IDENT -> StandardCharsets [33:24]
201 `--SEMI -> ; [33:40]
202 IMPORT -> import [34:0]
203 |--DOT -> . [34:20]
204 | |--DOT -> . [34:15]
205 | | |--DOT -> . [34:11]
206 | | | |--IDENT -> java [34:7]
207 | | | `--IDENT -> nio [34:12]
208 | | `--IDENT -> file [34:16]
209 | `--IDENT -> Files [34:21]
210 `--SEMI -> ; [34:26]
211 IMPORT -> import [35:0]
212 |--DOT -> . [35:20]
213 | |--DOT -> . [35:15]
214 | | |--DOT -> . [35:11]
215 | | | |--IDENT -> java [35:7]
216 | | | `--IDENT -> nio [35:12]
217 | | `--IDENT -> file [35:16]
218 | `--IDENT -> Paths [35:21]
219 `--SEMI -> ; [35:26]
220 IMPORT -> import [36:0]
221 |--DOT -> . [36:16]
222 | |--DOT -> . [36:11]
223 | | |--IDENT -> java [36:7]
224 | | `--IDENT -> util [36:12]
225 | `--IDENT -> ArrayList [36:17]
226 `--SEMI -> ; [36:26]
227 IMPORT -> import [37:0]
228 |--DOT -> . [37:16]
229 | |--DOT -> . [37:11]
230 | | |--IDENT -> java [37:7]
231 | | `--IDENT -> util [37:12]
232 | `--IDENT -> Arrays [37:17]
233 `--SEMI -> ; [37:23]
234 IMPORT -> import [38:0]
235 |--DOT -> . [38:16]
236 | |--DOT -> . [38:11]
237 | | |--IDENT -> java [38:7]
238 | | `--IDENT -> util [38:12]
239 | `--IDENT -> List [38:17]
240 `--SEMI -> ; [38:21]
241 IMPORT -> import [39:0]
242 |--DOT -> . [39:16]
243 | |--DOT -> . [39:11]
244 | | |--IDENT -> java [39:7]
245 | | `--IDENT -> util [39:12]
246 | `--IDENT -> Locale [39:17]
247 `--SEMI -> ; [39:23]
248 IMPORT -> import [40:0]
249 |--DOT -> . [40:22]
250 | |--DOT -> . [40:16]
251 | | |--DOT -> . [40:11]
252 | | | |--IDENT -> java [40:7]
253 | | | `--IDENT -> util [40:12]
254 | | `--IDENT -> regex [40:17]
255 | `--IDENT -> Matcher [40:23]
256 `--SEMI -> ; [40:30]
257 IMPORT -> import [41:0]
258 |--DOT -> . [41:22]
259 | |--DOT -> . [41:16]
260 | | |--DOT -> . [41:11]
261 | | | |--IDENT -> java [41:7]
262 | | | `--IDENT -> util [41:12]
263 | | `--IDENT -> regex [41:17]
264 | `--IDENT -> Pattern [41:23]
265 `--SEMI -> ; [41:30]
266 IMPORT -> import [43:0]
267 |--DOT -> . [43:28]
268 | |--DOT -> . [43:24]
269 | | |--DOT -> . [43:16]
270 | | | |--DOT -> . [43:10]
271 | | | | |--IDENT -> org [43:7]
272 | | | | `--IDENT -> junit [43:11]
273 | | | `--IDENT -> jupiter [43:17]
274 | | `--IDENT -> api [43:25]
275 | `--IDENT -> Test [43:29]
276 `--SEMI -> ; [43:33]
277 IMPORT -> import [45:0]
278 |--DOT -> . [45:38]
279 | |--DOT -> . [45:27]
280 | | |--DOT -> . [45:21]
281 | | | |--DOT -> . [45:10]
282 | | | | |--IDENT -> com [45:7]
283 | | | | `--IDENT -> puppycrawl [45:11]
284 | | | `--IDENT -> tools [45:22]
285 | | `--IDENT -> checkstyle [45:28]
286 | `--IDENT -> AbstractModuleTestSupport [45:39]
287 `--SEMI -> ; [45:64]
288 IMPORT -> import [46:0]
289 |--DOT -> . [46:38]
290 | |--DOT -> . [46:27]
291 | | |--DOT -> . [46:21]
292 | | | |--DOT -> . [46:10]
293 | | | | |--IDENT -> com [46:7]
294 | | | | `--IDENT -> puppycrawl [46:11]
295 | | | `--IDENT -> tools [46:22]
296 | | `--IDENT -> checkstyle [46:28]
297 | `--IDENT -> Checker [46:39]
298 `--SEMI -> ; [46:46]
299 IMPORT -> import [47:0]
300 |--DOT -> . [47:38]
301 | |--DOT -> . [47:27]
302 | | |--DOT -> . [47:21]
303 | | | |--DOT -> . [47:10]
304 | | | | |--IDENT -> com [47:7]
305 | | | | `--IDENT -> puppycrawl [47:11]
306 | | | `--IDENT -> tools [47:22]
307 | | `--IDENT -> checkstyle [47:28]
308 | `--IDENT -> DefaultConfiguration [47:39]
309 `--SEMI -> ; [47:59]
310 IMPORT -> import [48:0]
311 |--DOT -> . [48:42]
312 | |--DOT -> . [48:38]
313 | | |--DOT -> . [48:27]
314 | | | |--DOT -> . [48:21]
315 | | | | |--DOT -> . [48:10]
316 | | | | | |--IDENT -> com [48:7]
317 | | | | | `--IDENT -> puppycrawl [48:11]
318 | | | | `--IDENT -> tools [48:22]
319 | | | `--IDENT -> checkstyle [48:28]
320 | | `--IDENT -> api [48:39]
321 | `--IDENT -> AuditEvent [48:43]
322 `--SEMI -> ; [48:53]
323 IMPORT -> import [49:0]
324 |--DOT -> . [49:42]
325 | |--DOT -> . [49:38]
326 | | |--DOT -> . [49:27]
327 | | | |--DOT -> . [49:21]
328 | | | | |--DOT -> . [49:10]
329 | | | | | |--IDENT -> com [49:7]
330 | | | | | `--IDENT -> puppycrawl [49:11]
331 | | | | `--IDENT -> tools [49:22]
332 | | | `--IDENT -> checkstyle [49:28]
333 | | `--IDENT -> api [49:39]
334 | `--IDENT -> AuditListener [49:43]
335 `--SEMI -> ; [49:56]
336 IMPORT -> import [50:0]
337 |--DOT -> . [50:42]
338 | |--DOT -> . [50:38]
339 | | |--DOT -> . [50:27]
340 | | | |--DOT -> . [50:21]
341 | | | | |--DOT -> . [50:10]
342 | | | | | |--IDENT -> com [50:7]
343 | | | | | `--IDENT -> puppycrawl [50:11]
344 | | | | `--IDENT -> tools [50:22]
345 | | | `--IDENT -> checkstyle [50:28]
346 | | `--IDENT -> api [50:39]
347 | `--IDENT -> Configuration [50:43]
348 `--SEMI -> ; [50:56]
349 IMPORT -> import [51:0]
350 |--DOT -> . [51:44]
351 | |--DOT -> . [51:38]
352 | | |--DOT -> . [51:27]
353 | | | |--DOT -> . [51:21]
354 | | | | |--DOT -> . [51:10]
355 | | | | | |--IDENT -> com [51:7]
356 | | | | | `--IDENT -> puppycrawl [51:11]
357 | | | | `--IDENT -> tools [51:22]
358 | | | `--IDENT -> checkstyle [51:28]
359 | | `--IDENT -> utils [51:39]
360 | `--IDENT -> CommonUtil [51:45]
361 `--SEMI -> ; [51:55]
362 CLASS_DEF -> CLASS_DEF [56:0]
363 |--MODIFIERS -> MODIFIERS [56:0]
364 | |--BLOCK_COMMENT_BEGIN -> /* [53:0]
365 | | |--COMMENT_CONTENT -> *\n * Unit test for IndentationCheck.\n [53:2]
366 | | | `--JAVADOC -> JAVADOC [53:3]
367 | | | |--NEWLINE -> \n [53:3]
368 | | | |--LEADING_ASTERISK -> * [54:0]
369 | | | |--TEXT -> Unit test for IndentationCheck. [54:2]
370 | | | |--NEWLINE -> \n [54:34]
371 | | | |--TEXT -> [55:0]
372 | | | `--EOF -> <EOF> [55:1]
373 | | `--BLOCK_COMMENT_END -> */ [55:1]
374 | `--LITERAL_PUBLIC -> public [56:0]
375 |--LITERAL_CLASS -> class [56:7]
376 |--IDENT -> IndentationCheckTest [56:13]
377 |--EXTENDS_CLAUSE -> extends [56:34]
378 | `--IDENT -> AbstractModuleTestSupport [56:42]
379 `--OBJBLOCK -> OBJBLOCK [56:68]
380 |--LCURLY -> { [56:68]
381 |--VARIABLE_DEF -> VARIABLE_DEF [58:4]
382 | |--MODIFIERS -> MODIFIERS [58:4]
383 | | |--LITERAL_PRIVATE -> private [58:4]
384 | | |--LITERAL_STATIC -> static [58:12]
385 | | `--FINAL -> final [58:19]
386 | |--TYPE -> TYPE [58:25]
387 | | `--IDENT -> Pattern [58:25]
388 | |--IDENT -> LINE_WITH_COMMENT_REGEX [58:33]
389 | |--ASSIGN -> = [58:57]
390 | | `--EXPR -> EXPR [59:35]
391 | | `--METHOD_CALL -> ( [59:35]
392 | | |--DOT -> . [59:27]
393 | | | |--IDENT -> Pattern [59:20]
394 | | | `--IDENT -> compile [59:28]
395 | | |--ELIST -> ELIST [60:24]
396 | | | `--EXPR -> EXPR [60:24]
397 | | | `--PLUS -> + [60:24]
398 | | | |--STRING_LITERAL -> ".*?//indent:(\\d+)(?: ioffset:(\\d+))?" [59:36]
399 | | | `--STRING_LITERAL -> " exp:(>=)?(\\d+(?:,\\d+)*?)( warn)?$" [60:26]
400 | | `--RPAREN -> ) [60:64]
401 | `--SEMI -> ; [60:65]
402 |--VARIABLE_DEF -> VARIABLE_DEF [62:4]
403 | |--MODIFIERS -> MODIFIERS [62:4]
404 | | |--LITERAL_PRIVATE -> private [62:4]
405 | | |--LITERAL_STATIC -> static [62:12]
406 | | `--FINAL -> final [62:19]
407 | |--TYPE -> TYPE [62:38]
408 | | `--ARRAY_DECLARATOR -> [ [62:38]
409 | | |--IDENT -> IndentComment [62:25]
410 | | `--RBRACK -> ] [62:39]
411 | |--IDENT -> EMPTY_INDENT_COMMENT_ARRAY [62:41]
412 | |--ASSIGN -> = [62:68]
413 | | `--EXPR -> EXPR [62:70]
414 | | `--LITERAL_NEW -> new [62:70]
415 | | |--IDENT -> IndentComment [62:74]
416 | | `--ARRAY_DECLARATOR -> [ [62:87]
417 | | |--EXPR -> EXPR [62:88]
418 | | | `--NUM_INT -> 0 [62:88]
419 | | `--RBRACK -> ] [62:89]
420 | `--SEMI -> ; [62:90]
421 |--METHOD_DEF -> METHOD_DEF [64:4]
422 | |--MODIFIERS -> MODIFIERS [64:4]
423 | | |--LITERAL_PRIVATE -> private [64:4]
424 | | `--LITERAL_STATIC -> static [64:12]
425 | |--TYPE -> TYPE [64:32]
426 | | `--ARRAY_DECLARATOR -> [ [64:32]
427 | | |--IDENT -> IndentComment [64:19]
428 | | `--RBRACK -> ] [64:33]
429 | |--IDENT -> getLinesWithWarnAndCheckComments [64:35]
430 | |--LPAREN -> ( [64:67]
431 | |--PARAMETERS -> PARAMETERS [64:68]
432 | | |--PARAMETER_DEF -> PARAMETER_DEF [64:68]
433 | | | |--MODIFIERS -> MODIFIERS [64:68]
434 | | | |--TYPE -> TYPE [64:68]
435 | | | | `--IDENT -> String [64:68]
436 | | | `--IDENT -> aFileName [64:75]
437 | | |--COMMA -> , [64:84]
438 | | `--PARAMETER_DEF -> PARAMETER_DEF [65:12]
439 | | |--MODIFIERS -> MODIFIERS [65:12]
440 | | | `--FINAL -> final [65:12]
441 | | |--TYPE -> TYPE [65:18]
442 | | | `--LITERAL_INT -> int [65:18]
443 | | `--IDENT -> tabWidth [65:22]
444 | |--RPAREN -> ) [65:30]
445 | |--LITERAL_THROWS -> throws [66:20]
446 | | `--IDENT -> IOException [66:27]
447 | `--SLIST -> { [66:39]
448 | |--VARIABLE_DEF -> VARIABLE_DEF [67:8]
449 | | |--MODIFIERS -> MODIFIERS [67:8]
450 | | | `--FINAL -> final [67:8]
451 | | |--TYPE -> TYPE [67:14]
452 | | | |--IDENT -> List [67:14]
453 | | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [67:18]
454 | | | |--GENERIC_START -> < [67:18]
455 | | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT [67:19]
456 | | | | `--IDENT -> IndentComment [67:19]
457 | | | `--GENERIC_END -> > [67:32]
458 | | |--IDENT -> result [67:34]
459 | | `--ASSIGN -> = [67:41]
460 | | `--EXPR -> EXPR [67:43]
461 | | `--LITERAL_NEW -> new [67:43]
462 | | |--IDENT -> ArrayList [67:47]
463 | | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [67:56]
464 | | | |--GENERIC_START -> < [67:56]
465 | | | `--GENERIC_END -> > [67:57]
466 | | |--LPAREN -> ( [67:58]
467 | | |--ELIST -> ELIST [67:59]
468 | | `--RPAREN -> ) [67:59]
469 | |--SEMI -> ; [67:60]
470 | |--LITERAL_TRY -> try [68:8]
471 | | |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [68:12]
472 | | | |--LPAREN -> ( [68:12]
473 | | | |--RESOURCES -> RESOURCES [68:13]
474 | | | | `--RESOURCE -> RESOURCE [68:13]
475 | | | | |--MODIFIERS -> MODIFIERS [68:13]
476 | | | | |--TYPE -> TYPE [68:13]
477 | | | | | `--IDENT -> BufferedReader [68:13]
478 | | | | |--IDENT -> br [68:28]
479 | | | | `--ASSIGN -> = [68:31]
480 | | | | `--EXPR -> EXPR [68:56]
481 | | | | `--METHOD_CALL -> ( [68:56]
482 | | | | |--DOT -> . [68:38]
483 | | | | | |--IDENT -> Files [68:33]
484 | | | | | `--IDENT -> newBufferedReader [68:39]
485 | | | | |--ELIST -> ELIST [68:66]
486 | | | | | |--EXPR -> EXPR [68:66]
487 | | | | | | `--METHOD_CALL -> ( [68:66]
488 | | | | | | |--DOT -> . [68:62]
489 | | | | | | | |--IDENT -> Paths [68:57]
490 | | | | | | | `--IDENT -> get [68:63]
491 | | | | | | |--ELIST -> ELIST [68:67]
492 | | | | | | | `--EXPR -> EXPR [68:67]
493 | | | | | | | `--IDENT -> aFileName [68:67]
494 | | | | | | `--RPAREN -> ) [68:76]
495 | | | | | |--COMMA -> , [68:77]
496 | | | | | `--EXPR -> EXPR [69:32]
497 | | | | | `--DOT -> . [69:32]
498 | | | | | |--IDENT -> StandardCharsets [69:16]
499 | | | | | `--IDENT -> UTF_8 [69:33]
500 | | | | `--RPAREN -> ) [69:38]
501 | | | `--RPAREN -> ) [69:39]
502 | | `--SLIST -> { [69:41]
503 | | |--VARIABLE_DEF -> VARIABLE_DEF [70:12]
504 | | | |--MODIFIERS -> MODIFIERS [70:12]
505 | | | |--TYPE -> TYPE [70:12]
506 | | | | `--LITERAL_INT -> int [70:12]
507 | | | |--IDENT -> lineNumber [70:16]
508 | | | `--ASSIGN -> = [70:27]
509 | | | `--EXPR -> EXPR [70:29]
510 | | | `--NUM_INT -> 1 [70:29]
511 | | |--SEMI -> ; [70:30]
512 | | |--LITERAL_FOR -> for [71:12]
513 | | | |--LPAREN -> ( [71:16]
514 | | | |--FOR_INIT -> FOR_INIT [71:17]
515 | | | | `--VARIABLE_DEF -> VARIABLE_DEF [71:17]
516 | | | | |--MODIFIERS -> MODIFIERS [71:17]
517 | | | | |--TYPE -> TYPE [71:17]
518 | | | | | `--IDENT -> String [71:17]
519 | | | | |--IDENT -> line [71:24]
520 | | | | `--ASSIGN -> = [71:29]
521 | | | | `--EXPR -> EXPR [71:42]
522 | | | | `--METHOD_CALL -> ( [71:42]
523 | | | | |--DOT -> . [71:33]
524 | | | | | |--IDENT -> br [71:31]
525 | | | | | `--IDENT -> readLine [71:34]
526 | | | | |--ELIST -> ELIST [71:43]
527 | | | | `--RPAREN -> ) [71:43]
528 | | | |--SEMI -> ; [71:44]
529 | | | |--FOR_CONDITION -> FOR_CONDITION [71:51]
530 | | | | `--EXPR -> EXPR [71:51]
531 | | | | `--NOT_EQUAL -> != [71:51]
532 | | | | |--IDENT -> line [71:46]
533 | | | | `--LITERAL_NULL -> null [71:54]
534 | | | |--SEMI -> ; [71:58]
535 | | | |--FOR_ITERATOR -> FOR_ITERATOR [71:65]
536 | | | | `--ELIST -> ELIST [71:65]
537 | | | | `--EXPR -> EXPR [71:65]
538 | | | | `--ASSIGN -> = [71:65]
539 | | | | |--IDENT -> line [71:60]
540 | | | | `--METHOD_CALL -> ( [71:78]
541 | | | | |--DOT -> . [71:69]
542 | | | | | |--IDENT -> br [71:67]
543 | | | | | `--IDENT -> readLine [71:70]
544 | | | | |--ELIST -> ELIST [71:79]
545 | | | | `--RPAREN -> ) [71:79]
546 | | | |--RPAREN -> ) [71:80]
547 | | | `--SLIST -> { [71:82]
548 | | | |--VARIABLE_DEF -> VARIABLE_DEF [72:16]
549 | | | | |--MODIFIERS -> MODIFIERS [72:16]
550 | | | | | `--FINAL -> final [72:16]
551 | | | | |--TYPE -> TYPE [72:22]
552 | | | | | `--IDENT -> Matcher [72:22]
553 | | | | |--IDENT -> match [72:30]
554 | | | | `--ASSIGN -> = [72:36]
555 | | | | `--EXPR -> EXPR [72:69]
556 | | | | `--METHOD_CALL -> ( [72:69]
557 | | | | |--DOT -> . [72:61]
558 | | | | | |--IDENT -> LINE_WITH_COMMENT_REGEX [72:38]
559 | | | | | `--IDENT -> matcher [72:62]
560 | | | | |--ELIST -> ELIST [72:70]
561 | | | | | `--EXPR -> EXPR [72:70]
562 | | | | | `--IDENT -> line [72:70]
563 | | | | `--RPAREN -> ) [72:74]
564 | | | |--SEMI -> ; [72:75]
565 | | | |--LITERAL_IF -> if [73:16]
566 | | | | |--LPAREN -> ( [73:19]
567 | | | | |--EXPR -> EXPR [73:33]
568 | | | | | `--METHOD_CALL -> ( [73:33]
569 | | | | | |--DOT -> . [73:25]
570 | | | | | | |--IDENT -> match [73:20]
571 | | | | | | `--IDENT -> matches [73:26]
572 | | | | | |--ELIST -> ELIST [73:34]
573 | | | | | `--RPAREN -> ) [73:34]
574 | | | | |--RPAREN -> ) [73:35]
575 | | | | |--SLIST -> { [73:37]
576 | | | | | |--VARIABLE_DEF -> VARIABLE_DEF [74:20]
577 | | | | | | |--MODIFIERS -> MODIFIERS [74:20]
578 | | | | | | | `--FINAL -> final [74:20]
579 | | | | | | |--TYPE -> TYPE [74:26]
580 | | | | | | | `--IDENT -> IndentComment [74:26]
581 | | | | | | |--IDENT -> warn [74:40]
582 | | | | | | `--ASSIGN -> = [74:45]
583 | | | | | | `--EXPR -> EXPR [74:47]
584 | | | | | | `--LITERAL_NEW -> new [74:47]
585 | | | | | | |--IDENT -> IndentComment [74:51]
586 | | | | | | |--LPAREN -> ( [74:64]
587 | | | | | | |--ELIST -> ELIST [74:65]
588 | | | | | | | |--EXPR -> EXPR [74:65]
589 | | | | | | | | `--IDENT -> match [74:65]
590 | | | | | | | |--COMMA -> , [74:70]
591 | | | | | | | `--EXPR -> EXPR [74:72]
592 | | | | | | | `--IDENT -> lineNumber [74:72]
593 | | | | | | `--RPAREN -> ) [74:82]
594 | | | | | |--SEMI -> ; [74:83]
595 | | | | | |--VARIABLE_DEF -> VARIABLE_DEF [75:20]
596 | | | | | | |--MODIFIERS -> MODIFIERS [75:20]
597 | | | | | | | `--FINAL -> final [75:20]
598 | | | | | | |--TYPE -> TYPE [75:26]
599 | | | | | | | `--LITERAL_INT -> int [75:26]
600 | | | | | | |--IDENT -> actualIndent [75:30]
601 | | | | | | `--ASSIGN -> = [75:43]
602 | | | | | | `--EXPR -> EXPR [75:57]
603 | | | | | | `--METHOD_CALL -> ( [75:57]
604 | | | | | | |--IDENT -> getLineStart [75:45]
605 | | | | | | |--ELIST -> ELIST [75:58]
606 | | | | | | | |--EXPR -> EXPR [75:58]
607 | | | | | | | | `--IDENT -> line [75:58]
608 | | | | | | | |--COMMA -> , [75:62]
609 | | | | | | | `--EXPR -> EXPR [75:64]
610 | | | | | | | `--IDENT -> tabWidth [75:64]
611 | | | | | | `--RPAREN -> ) [75:72]
612 | | | | | |--SEMI -> ; [75:73]
613 | | | | | |--LITERAL_IF -> if [77:20]
614 | | | | | | |--LPAREN -> ( [77:23]
615 | | | | | | |--EXPR -> EXPR [77:37]
616 | | | | | | | `--NOT_EQUAL -> != [77:37]
617 | | | | | | | |--IDENT -> actualIndent [77:24]
618 | | | | | | | `--METHOD_CALL -> ( [77:54]
619 | | | | | | | |--DOT -> . [77:44]
620 | | | | | | | | |--IDENT -> warn [77:40]
621 | | | | | | | | `--IDENT -> getIndent [77:45]
622 | | | | | | | |--ELIST -> ELIST [77:55]
623 | | | | | | | `--RPAREN -> ) [77:55]
624 | | | | | | |--RPAREN -> ) [77:56]
625 | | | | | | `--SLIST -> { [77:58]
626 | | | | | | |--LITERAL_THROW -> throw [78:24]
627 | | | | | | | |--EXPR -> EXPR [78:30]
628 | | | | | | | | `--LITERAL_NEW -> new [78:30]
629 | | | | | | | | |--IDENT -> IllegalStateException [78:34]
630 | | | | | | | | |--LPAREN -> ( [78:55]
631 | | | | | | | | |--ELIST -> ELIST [78:69]
632 | | | | | | | | | `--EXPR -> EXPR [78:69]
633 | | | | | | | | | `--METHOD_CALL -> ( [78:69]
634 | | | | | | | | | |--DOT -> . [78:62]
635 | | | | | | | | | | |--IDENT -> String [78:56]
636 | | | | | | | | | | `--IDENT -> format [78:63]
637 | | | | | | | | | |--ELIST -> ELIST [78:76]
638 | | | | | | | | | | |--EXPR -> EXPR [78:76]
639 | | | | | | | | | | | `--DOT -> . [78:76]
640 | | | | | | | | | | | |--IDENT -> Locale [78:70]
641 | | | | | | | | | | | `--IDENT -> ROOT [78:77]
642 | | | | | | | | | | |--COMMA -> , [78:81]
643 | | | | | | | | | | |--EXPR -> EXPR [80:56]
644 | | | | | | | | | | | `--PLUS -> + [80:56]
645 | | | | | | | | | | | |--STRING_LITERAL -> "File \"%1$s\" has incorrect indentation in comment. " [79:40]
646 | | | | | | | | | | | `--STRING_LITERAL -> "Line %2$d: comment:%3$d, actual:%4$d." [80:58]
647 | | | | | | | | | | |--COMMA -> , [80:97]
648 | | | | | | | | | | |--EXPR -> EXPR [81:40]
649 | | | | | | | | | | | `--IDENT -> aFileName [81:40]
650 | | | | | | | | | | |--COMMA -> , [81:49]
651 | | | | | | | | | | |--EXPR -> EXPR [82:40]
652 | | | | | | | | | | | `--IDENT -> lineNumber [82:40]
653 | | | | | | | | | | |--COMMA -> , [82:50]
654 | | | | | | | | | | |--EXPR -> EXPR [83:54]
655 | | | | | | | | | | | `--METHOD_CALL -> ( [83:54]
656 | | | | | | | | | | | |--DOT -> . [83:44]
657 | | | | | | | | | | | | |--IDENT -> warn [83:40]
658 | | | | | | | | | | | | `--IDENT -> getIndent [83:45]
659 | | | | | | | | | | | |--ELIST -> ELIST [83:55]
660 | | | | | | | | | | | `--RPAREN -> ) [83:55]
661 | | | | | | | | | | |--COMMA -> , [83:56]
662 | | | | | | | | | | `--EXPR -> EXPR [84:40]
663 | | | | | | | | | | `--IDENT -> actualIndent [84:40]
664 | | | | | | | | | `--RPAREN -> ) [84:52]
665 | | | | | | | | `--RPAREN -> ) [84:53]
666 | | | | | | | `--SEMI -> ; [84:54]
667 | | | | | | `--RCURLY -> } [85:20]
668 | | | | | |--LITERAL_IF -> if [87:20]
669 | | | | | | |--LPAREN -> ( [87:23]
670 | | | | | | |--EXPR -> EXPR [87:24]
671 | | | | | | | `--LNOT -> ! [87:24]
672 | | | | | | | `--METHOD_CALL -> ( [87:44]
673 | | | | | | | |--IDENT -> isCommentConsistent [87:25]
674 | | | | | | | |--ELIST -> ELIST [87:45]
675 | | | | | | | | `--EXPR -> EXPR [87:45]
676 | | | | | | | | `--IDENT -> warn [87:45]
677 | | | | | | | `--RPAREN -> ) [87:49]
678 | | | | | | |--RPAREN -> ) [87:50]
679 | | | | | | `--SLIST -> { [87:52]
680 | | | | | | |--LITERAL_THROW -> throw [88:24]
681 | | | | | | | |--EXPR -> EXPR [88:30]
682 | | | | | | | | `--LITERAL_NEW -> new [88:30]
683 | | | | | | | | |--IDENT -> IllegalStateException [88:34]
684 | | | | | | | | |--LPAREN -> ( [88:55]
685 | | | | | | | | |--ELIST -> ELIST [88:69]
686 | | | | | | | | | `--EXPR -> EXPR [88:69]
687 | | | | | | | | | `--METHOD_CALL -> ( [88:69]
688 | | | | | | | | | |--DOT -> . [88:62]
689 | | | | | | | | | | |--IDENT -> String [88:56]
690 | | | | | | | | | | `--IDENT -> format [88:63]
691 | | | | | | | | | |--ELIST -> ELIST [88:76]
692 | | | | | | | | | | |--EXPR -> EXPR [88:76]
693 | | | | | | | | | | | `--DOT -> . [88:76]
694 | | | | | | | | | | | |--IDENT -> Locale [88:70]
695 | | | | | | | | | | | `--IDENT -> ROOT [88:77]
696 | | | | | | | | | | |--COMMA -> , [88:81]
697 | | | | | | | | | | |--EXPR -> EXPR [89:40]
698 | | | | | | | | | | | `--STRING_LITERAL -> "File \"%1$s\" has inconsistent comment on line %2$d" [89:40]
699 | | | | | | | | | | |--COMMA -> , [89:93]
700 | | | | | | | | | | |--EXPR -> EXPR [90:40]
701 | | | | | | | | | | | `--IDENT -> aFileName [90:40]
702 | | | | | | | | | | |--COMMA -> , [90:49]
703 | | | | | | | | | | `--EXPR -> EXPR [91:40]
704 | | | | | | | | | | `--IDENT -> lineNumber [91:40]
705 | | | | | | | | | `--RPAREN -> ) [91:50]
706 | | | | | | | | `--RPAREN -> ) [91:51]
707 | | | | | | | `--SEMI -> ; [91:52]
708 | | | | | | `--RCURLY -> } [92:20]
709 | | | | | |--LITERAL_IF -> if [94:20]
710 | | | | | | |--LPAREN -> ( [94:23]
711 | | | | | | |--EXPR -> EXPR [94:38]
712 | | | | | | | `--METHOD_CALL -> ( [94:38]
713 | | | | | | | |--DOT -> . [94:28]
714 | | | | | | | | |--IDENT -> warn [94:24]
715 | | | | | | | | `--IDENT -> isWarning [94:29]
716 | | | | | | | |--ELIST -> ELIST [94:39]
717 | | | | | | | `--RPAREN -> ) [94:39]
718 | | | | | | |--RPAREN -> ) [94:40]
719 | | | | | | `--SLIST -> { [94:42]
720 | | | | | | |--EXPR -> EXPR [95:34]
721 | | | | | | | `--METHOD_CALL -> ( [95:34]
722 | | | | | | | |--DOT -> . [95:30]
723 | | | | | | | | |--IDENT -> result [95:24]
724 | | | | | | | | `--IDENT -> add [95:31]
725 | | | | | | | |--ELIST -> ELIST [95:35]
726 | | | | | | | | `--EXPR -> EXPR [95:35]
727 | | | | | | | | `--IDENT -> warn [95:35]
728 | | | | | | | `--RPAREN -> ) [95:39]
729 | | | | | | |--SEMI -> ; [95:40]
730 | | | | | | `--RCURLY -> } [96:20]
731 | | | | | `--RCURLY -> } [97:16]
732 | | | | `--LITERAL_ELSE -> else [98:16]
733 | | | | `--LITERAL_IF -> if [98:21]
734 | | | | |--LPAREN -> ( [98:24]
735 | | | | |--EXPR -> EXPR [98:25]
736 | | | | | `--LNOT -> ! [98:25]
737 | | | | | `--METHOD_CALL -> ( [98:38]
738 | | | | | |--DOT -> . [98:30]
739 | | | | | | |--IDENT -> line [98:26]
740 | | | | | | `--IDENT -> isEmpty [98:31]
741 | | | | | |--ELIST -> ELIST [98:39]
742 | | | | | `--RPAREN -> ) [98:39]
743 | | | | |--RPAREN -> ) [98:40]
744 | | | | `--SLIST -> { [98:42]
745 | | | | |--LITERAL_THROW -> throw [99:20]
746 | | | | | |--EXPR -> EXPR [99:26]
747 | | | | | | `--LITERAL_NEW -> new [99:26]
748 | | | | | | |--IDENT -> IllegalStateException [99:30]
749 | | | | | | |--LPAREN -> ( [99:51]
750 | | | | | | |--ELIST -> ELIST [99:65]
751 | | | | | | | `--EXPR -> EXPR [99:65]
752 | | | | | | | `--METHOD_CALL -> ( [99:65]
753 | | | | | | | |--DOT -> . [99:58]
754 | | | | | | | | |--IDENT -> String [99:52]
755 | | | | | | | | `--IDENT -> format [99:59]
756 | | | | | | | |--ELIST -> ELIST [99:72]
757 | | | | | | | | |--EXPR -> EXPR [99:72]
758 | | | | | | | | | `--DOT -> . [99:72]
759 | | | | | | | | | |--IDENT -> Locale [99:66]
760 | | | | | | | | | `--IDENT -> ROOT [99:73]
761 | | | | | | | | |--COMMA -> , [99:77]
762 | | | | | | | | |--EXPR -> EXPR [101:52]
763 | | | | | | | | | `--PLUS -> + [101:52]
764 | | | | | | | | | |--STRING_LITERAL -> "File \"%1$s\" has no indentation comment or its format " [100:36]
765 | | | | | | | | | `--STRING_LITERAL -> "malformed. Error on line: %2$d" [101:54]
766 | | | | | | | | |--COMMA -> , [101:86]
767 | | | | | | | | |--EXPR -> EXPR [102:36]
768 | | | | | | | | | `--IDENT -> aFileName [102:36]
769 | | | | | | | | |--COMMA -> , [102:45]
770 | | | | | | | | `--EXPR -> EXPR [103:36]
771 | | | | | | | | `--IDENT -> lineNumber [103:36]
772 | | | | | | | `--RPAREN -> ) [103:46]
773 | | | | | | `--RPAREN -> ) [103:47]
774 | | | | | `--SEMI -> ; [103:48]
775 | | | | `--RCURLY -> } [104:16]
776 | | | |--EXPR -> EXPR [105:26]
777 | | | | `--POST_INC -> ++ [105:26]
778 | | | | `--IDENT -> lineNumber [105:16]
779 | | | |--SEMI -> ; [105:28]
780 | | | `--RCURLY -> } [106:12]
781 | | `--RCURLY -> } [107:8]
782 | |--LITERAL_RETURN -> return [108:8]
783 | | |--EXPR -> EXPR [108:29]
784 | | | `--METHOD_CALL -> ( [108:29]
785 | | | |--DOT -> . [108:21]
786 | | | | |--IDENT -> result [108:15]
787 | | | | `--IDENT -> toArray [108:22]
788 | | | |--ELIST -> ELIST [108:30]
789 | | | | `--EXPR -> EXPR [108:30]
790 | | | | `--IDENT -> EMPTY_INDENT_COMMENT_ARRAY [108:30]
791 | | | `--RPAREN -> ) [108:56]
792 | | `--SEMI -> ; [108:57]
793 | `--RCURLY -> } [109:4]
794 |--METHOD_DEF -> METHOD_DEF [111:4]
795 | |--MODIFIERS -> MODIFIERS [111:4]
796 | | |--LITERAL_PRIVATE -> private [111:4]
797 | | `--LITERAL_STATIC -> static [111:12]
798 | |--TYPE -> TYPE [111:19]
799 | | `--LITERAL_BOOLEAN -> boolean [111:19]
800 | |--IDENT -> isCommentConsistent [111:27]
801 | |--LPAREN -> ( [111:46]
802 | |--PARAMETERS -> PARAMETERS [111:47]
803 | | `--PARAMETER_DEF -> PARAMETER_DEF [111:47]
804 | | |--MODIFIERS -> MODIFIERS [111:47]
805 | | |--TYPE -> TYPE [111:47]
806 | | | `--IDENT -> IndentComment [111:47]
807 | | `--IDENT -> comment [111:61]
808 | |--RPAREN -> ) [111:68]
809 | `--SLIST -> { [111:70]
810 | |--VARIABLE_DEF -> VARIABLE_DEF [112:8]
811 | | |--MODIFIERS -> MODIFIERS [112:8]
812 | | | `--FINAL -> final [112:8]
813 | | |--TYPE -> TYPE [112:20]
814 | | | `--ARRAY_DECLARATOR -> [ [112:20]
815 | | | |--IDENT -> String [112:14]
816 | | | `--RBRACK -> ] [112:21]
817 | | |--IDENT -> levels [112:23]
818 | | `--ASSIGN -> = [112:30]
819 | | `--EXPR -> EXPR [112:66]
820 | | `--METHOD_CALL -> ( [112:66]
821 | | |--DOT -> . [112:60]
822 | | | |--METHOD_CALL -> ( [112:58]
823 | | | | |--DOT -> . [112:39]
824 | | | | | |--IDENT -> comment [112:32]
825 | | | | | `--IDENT -> getExpectedWarning [112:40]
826 | | | | |--ELIST -> ELIST [112:59]
827 | | | | `--RPAREN -> ) [112:59]
828 | | | `--IDENT -> split [112:61]
829 | | |--ELIST -> ELIST [112:67]
830 | | | `--EXPR -> EXPR [112:67]
831 | | | `--STRING_LITERAL -> ", " [112:67]
832 | | `--RPAREN -> ) [112:71]
833 | |--SEMI -> ; [112:72]
834 | |--VARIABLE_DEF -> VARIABLE_DEF [113:8]
835 | | |--MODIFIERS -> MODIFIERS [113:8]
836 | | | `--FINAL -> final [113:8]
837 | | |--TYPE -> TYPE [113:14]
838 | | | `--LITERAL_INT -> int [113:14]
839 | | |--IDENT -> indent [113:18]
840 | | `--ASSIGN -> = [113:25]
841 | | `--EXPR -> EXPR [113:47]
842 | | `--PLUS -> + [113:47]
843 | | |--METHOD_CALL -> ( [113:44]
844 | | | |--DOT -> . [113:34]
845 | | | | |--IDENT -> comment [113:27]
846 | | | | `--IDENT -> getIndent [113:35]
847 | | | |--ELIST -> ELIST [113:45]
848 | | | `--RPAREN -> ) [113:45]
849 | | `--METHOD_CALL -> ( [113:72]
850 | | |--DOT -> . [113:56]
851 | | | |--IDENT -> comment [113:49]
852 | | | `--IDENT -> getIndentOffset [113:57]
853 | | |--ELIST -> ELIST [113:73]
854 | | `--RPAREN -> ) [113:73]
855 | |--SEMI -> ; [113:74]
856 | |--VARIABLE_DEF -> VARIABLE_DEF [114:8]
857 | | |--MODIFIERS -> MODIFIERS [114:8]
858 | | | `--FINAL -> final [114:8]
859 | | |--TYPE -> TYPE [114:14]
860 | | | `--LITERAL_BOOLEAN -> boolean [114:14]
861 | | `--IDENT -> result [114:22]
862 | |--SEMI -> ; [114:28]
863 | |--LITERAL_IF -> if [115:8]
864 | | |--LPAREN -> ( [115:11]
865 | | |--EXPR -> EXPR [115:26]
866 | | | `--GT -> > [115:26]
867 | | | |--DOT -> . [115:18]
868 | | | | |--IDENT -> levels [115:12]
869 | | | | `--IDENT -> length [115:19]
870 | | | `--NUM_INT -> 1 [115:28]
871 | | |--RPAREN -> ) [115:29]
872 | | |--SLIST -> { [115:31]
873 | | | |--VARIABLE_DEF -> VARIABLE_DEF [117:12]
874 | | | | |--MODIFIERS -> MODIFIERS [117:12]
875 | | | | | |--SINGLE_LINE_COMMENT -> // [116:12]
876 | | | | | | `--COMMENT_CONTENT -> multi\n [116:14]
877 | | | | | `--FINAL -> final [117:12]
878 | | | | |--TYPE -> TYPE [117:18]
879 | | | | | `--LITERAL_BOOLEAN -> boolean [117:18]
880 | | | | |--IDENT -> containsActualLevel [117:26]
881 | | | | `--ASSIGN -> = [117:46]
882 | | | | `--EXPR -> EXPR [118:58]
883 | | | | `--METHOD_CALL -> ( [118:58]
884 | | | | |--DOT -> . [118:49]
885 | | | | | |--METHOD_CALL -> ( [118:41]
886 | | | | | | |--DOT -> . [118:34]
887 | | | | | | | |--IDENT -> Arrays [118:28]
888 | | | | | | | `--IDENT -> asList [118:35]
889 | | | | | | |--ELIST -> ELIST [118:42]
890 | | | | | | | `--EXPR -> EXPR [118:42]
891 | | | | | | | `--IDENT -> levels [118:42]
892 | | | | | | `--RPAREN -> ) [118:48]
893 | | | | | `--IDENT -> contains [118:50]
894 | | | | |--ELIST -> ELIST [118:73]
895 | | | | | `--EXPR -> EXPR [118:73]
896 | | | | | `--METHOD_CALL -> ( [118:73]
897 | | | | | |--DOT -> . [118:65]
898 | | | | | | |--IDENT -> String [118:59]
899 | | | | | | `--IDENT -> valueOf [118:66]
900 | | | | | |--ELIST -> ELIST [118:74]
901 | | | | | | `--EXPR -> EXPR [118:74]
902 | | | | | | `--IDENT -> indent [118:74]
903 | | | | | `--RPAREN -> ) [118:80]
904 | | | | `--RPAREN -> ) [118:81]
905 | | | |--SEMI -> ; [118:82]
906 | | | |--EXPR -> EXPR [120:19]
907 | | | | `--ASSIGN -> = [120:19]
908 | | | | |--IDENT -> result [120:12]
909 | | | | `--NOT_EQUAL -> != [120:41]
910 | | | | |--IDENT -> containsActualLevel [120:21]
911 | | | | `--METHOD_CALL -> ( [120:61]
912 | | | | |--DOT -> . [120:51]
913 | | | | | |--IDENT -> comment [120:44]
914 | | | | | `--IDENT -> isWarning [120:52]
915 | | | | |--ELIST -> ELIST [120:62]
916 | | | | `--RPAREN -> ) [120:62]
917 | | | |--SEMI -> ; [120:63]
918 | | | `--RCURLY -> } [121:8]
919 | | `--LITERAL_ELSE -> else [122:8]
920 | | `--SLIST -> { [122:13]
921 | | |--VARIABLE_DEF -> VARIABLE_DEF [123:12]
922 | | | |--MODIFIERS -> MODIFIERS [123:12]
923 | | | | `--FINAL -> final [123:12]
924 | | | |--TYPE -> TYPE [123:18]
925 | | | | `--LITERAL_INT -> int [123:18]
926 | | | |--IDENT -> expectedWarning [123:22]
927 | | | `--ASSIGN -> = [123:38]
928 | | | `--EXPR -> EXPR [123:56]
929 | | | `--METHOD_CALL -> ( [123:56]
930 | | | |--DOT -> . [123:47]
931 | | | | |--IDENT -> Integer [123:40]
932 | | | | `--IDENT -> parseInt [123:48]
933 | | | |--ELIST -> ELIST [123:83]
934 | | | | `--EXPR -> EXPR [123:83]
935 | | | | `--METHOD_CALL -> ( [123:83]
936 | | | | |--DOT -> . [123:64]
937 | | | | | |--IDENT -> comment [123:57]
938 | | | | | `--IDENT -> getExpectedWarning [123:65]
939 | | | | |--ELIST -> ELIST [123:84]
940 | | | | `--RPAREN -> ) [123:84]
941 | | | `--RPAREN -> ) [123:85]
942 | | |--SEMI -> ; [123:86]
943 | | |--VARIABLE_DEF -> VARIABLE_DEF [125:12]
944 | | | |--MODIFIERS -> MODIFIERS [125:12]
945 | | | | `--FINAL -> final [125:12]
946 | | | |--TYPE -> TYPE [125:18]
947 | | | | `--LITERAL_BOOLEAN -> boolean [125:18]
948 | | | `--IDENT -> test [125:26]
949 | | |--SEMI -> ; [125:30]
950 | | |--LITERAL_IF -> if [126:12]
951 | | | |--LPAREN -> ( [126:15]
952 | | | |--EXPR -> EXPR [126:43]
953 | | | | `--METHOD_CALL -> ( [126:43]
954 | | | | |--DOT -> . [126:23]
955 | | | | | |--IDENT -> comment [126:16]
956 | | | | | `--IDENT -> isExpectedNonStrict [126:24]
957 | | | | |--ELIST -> ELIST [126:44]
958 | | | | `--RPAREN -> ) [126:44]
959 | | | |--RPAREN -> ) [126:45]
960 | | | |--SLIST -> { [126:47]
961 | | | | |--EXPR -> EXPR [128:21]
962 | | | | | `--ASSIGN -> = [128:21]
963 | | | | | |--SINGLE_LINE_COMMENT -> // [127:16]
964 | | | | | | `--COMMENT_CONTENT -> non-strict\n [127:18]
965 | | | | | |--IDENT -> test [128:16]
966 | | | | | `--GE -> >= [128:30]
967 | | | | | |--IDENT -> indent [128:23]
968 | | | | | `--IDENT -> expectedWarning [128:33]
969 | | | | |--SEMI -> ; [128:48]
970 | | | | `--RCURLY -> } [129:12]
971 | | | `--LITERAL_ELSE -> else [130:12]
972 | | | `--SLIST -> { [130:17]
973 | | | |--EXPR -> EXPR [132:21]
974 | | | | `--ASSIGN -> = [132:21]
975 | | | | |--SINGLE_LINE_COMMENT -> // [131:16]
976 | | | | | `--COMMENT_CONTENT -> single\n [131:18]
977 | | | | |--IDENT -> test [132:16]
978 | | | | `--EQUAL -> == [132:39]
979 | | | | |--IDENT -> expectedWarning [132:23]
980 | | | | `--IDENT -> indent [132:42]
981 | | | |--SEMI -> ; [132:48]
982 | | | `--RCURLY -> } [133:12]
983 | | |--EXPR -> EXPR [134:19]
984 | | | `--ASSIGN -> = [134:19]
985 | | | |--IDENT -> result [134:12]
986 | | | `--NOT_EQUAL -> != [134:26]
987 | | | |--IDENT -> test [134:21]
988 | | | `--METHOD_CALL -> ( [134:46]
989 | | | |--DOT -> . [134:36]
990 | | | | |--IDENT -> comment [134:29]
991 | | | | `--IDENT -> isWarning [134:37]
992 | | | |--ELIST -> ELIST [134:47]
993 | | | `--RPAREN -> ) [134:47]
994 | | |--SEMI -> ; [134:48]
995 | | `--RCURLY -> } [136:8]
996 | |--LITERAL_RETURN -> return [137:8]
997 | | |--EXPR -> EXPR [137:15]
998 | | | `--IDENT -> result [137:15]
999 | | `--SEMI -> ; [137:21]
1000 | `--RCURLY -> } [138:4]
1001 |--METHOD_DEF -> METHOD_DEF [140:4]
1002 | |--MODIFIERS -> MODIFIERS [140:4]
1003 | | |--LITERAL_PRIVATE -> private [140:4]
1004 | | `--LITERAL_STATIC -> static [140:12]
1005 | |--TYPE -> TYPE [140:19]
1006 | | `--LITERAL_INT -> int [140:19]
1007 | |--IDENT -> getLineStart [140:23]
1008 | |--LPAREN -> ( [140:35]
1009 | |--PARAMETERS -> PARAMETERS [140:36]
1010 | | |--PARAMETER_DEF -> PARAMETER_DEF [140:36]
1011 | | | |--MODIFIERS -> MODIFIERS [140:36]
1012 | | | |--TYPE -> TYPE [140:36]
1013 | | | | `--IDENT -> String [140:36]
1014 | | | `--IDENT -> line [140:43]
1015 | | |--COMMA -> , [140:47]
1016 | | `--PARAMETER_DEF -> PARAMETER_DEF [140:49]
1017 | | |--MODIFIERS -> MODIFIERS [140:49]
1018 | | | `--FINAL -> final [140:49]
1019 | | |--TYPE -> TYPE [140:55]
1020 | | | `--LITERAL_INT -> int [140:55]
1021 | | `--IDENT -> tabWidth [140:59]
1022 | |--RPAREN -> ) [140:67]
1023 | `--SLIST -> { [140:69]
1024 | |--VARIABLE_DEF -> VARIABLE_DEF [141:8]
1025 | | |--MODIFIERS -> MODIFIERS [141:8]
1026 | | |--TYPE -> TYPE [141:8]
1027 | | | `--LITERAL_INT -> int [141:8]
1028 | | |--IDENT -> lineStart [141:12]
1029 | | `--ASSIGN -> = [141:22]
1030 | | `--EXPR -> EXPR [141:24]
1031 | | `--NUM_INT -> 0 [141:24]
1032 | |--SEMI -> ; [141:25]
1033 | |--LITERAL_FOR -> for [142:8]
1034 | | |--LPAREN -> ( [142:12]
1035 | | |--FOR_INIT -> FOR_INIT [142:13]
1036 | | | `--VARIABLE_DEF -> VARIABLE_DEF [142:13]
1037 | | | |--MODIFIERS -> MODIFIERS [142:13]
1038 | | | |--TYPE -> TYPE [142:13]
1039 | | | | `--LITERAL_INT -> int [142:13]
1040 | | | |--IDENT -> index [142:17]
1041 | | | `--ASSIGN -> = [142:23]
1042 | | | `--EXPR -> EXPR [142:25]
1043 | | | `--NUM_INT -> 0 [142:25]
1044 | | |--SEMI -> ; [142:26]
1045 | | |--FOR_CONDITION -> FOR_CONDITION [142:34]
1046 | | | `--EXPR -> EXPR [142:34]
1047 | | | `--LT -> < [142:34]
1048 | | | |--IDENT -> index [142:28]
1049 | | | `--METHOD_CALL -> ( [142:47]
1050 | | | |--DOT -> . [142:40]
1051 | | | | |--IDENT -> line [142:36]
1052 | | | | `--IDENT -> length [142:41]
1053 | | | |--ELIST -> ELIST [142:48]
1054 | | | `--RPAREN -> ) [142:48]
1055 | | |--SEMI -> ; [142:49]
1056 | | |--FOR_ITERATOR -> FOR_ITERATOR [142:51]
1057 | | | `--ELIST -> ELIST [142:51]
1058 | | | `--EXPR -> EXPR [142:51]
1059 | | | `--INC -> ++ [142:51]
1060 | | | `--IDENT -> index [142:53]
1061 | | |--RPAREN -> ) [142:58]
1062 | | `--SLIST -> { [142:60]
1063 | | |--LITERAL_IF -> if [143:12]
1064 | | | |--LPAREN -> ( [143:15]
1065 | | | |--EXPR -> EXPR [143:16]
1066 | | | | `--LNOT -> ! [143:16]
1067 | | | | `--METHOD_CALL -> ( [143:39]
1068 | | | | |--DOT -> . [143:26]
1069 | | | | | |--IDENT -> Character [143:17]
1070 | | | | | `--IDENT -> isWhitespace [143:27]
1071 | | | | |--ELIST -> ELIST [143:51]
1072 | | | | | `--EXPR -> EXPR [143:51]
1073 | | | | | `--METHOD_CALL -> ( [143:51]
1074 | | | | | |--DOT -> . [143:44]
1075 | | | | | | |--IDENT -> line [143:40]
1076 | | | | | | `--IDENT -> charAt [143:45]
1077 | | | | | |--ELIST -> ELIST [143:52]
1078 | | | | | | `--EXPR -> EXPR [143:52]
1079 | | | | | | `--IDENT -> index [143:52]
1080 | | | | | `--RPAREN -> ) [143:57]
1081 | | | | `--RPAREN -> ) [143:58]
1082 | | | |--RPAREN -> ) [143:59]
1083 | | | `--SLIST -> { [143:61]
1084 | | | |--EXPR -> EXPR [144:26]
1085 | | | | `--ASSIGN -> = [144:26]
1086 | | | | |--IDENT -> lineStart [144:16]
1087 | | | | `--METHOD_CALL -> ( [144:57]
1088 | | | | |--DOT -> . [144:38]
1089 | | | | | |--IDENT -> CommonUtil [144:28]
1090 | | | | | `--IDENT -> lengthExpandedTabs [144:39]
1091 | | | | |--ELIST -> ELIST [144:58]
1092 | | | | | |--EXPR -> EXPR [144:58]
1093 | | | | | | `--IDENT -> line [144:58]
1094 | | | | | |--COMMA -> , [144:62]
1095 | | | | | |--EXPR -> EXPR [144:64]
1096 | | | | | | `--IDENT -> index [144:64]
1097 | | | | | |--COMMA -> , [144:69]
1098 | | | | | `--EXPR -> EXPR [144:71]
1099 | | | | | `--IDENT -> tabWidth [144:71]
1100 | | | | `--RPAREN -> ) [144:79]
1101 | | | |--SEMI -> ; [144:80]
1102 | | | |--LITERAL_BREAK -> break [145:16]
1103 | | | | `--SEMI -> ; [145:21]
1104 | | | `--RCURLY -> } [146:12]
1105 | | `--RCURLY -> } [147:8]
1106 | |--LITERAL_RETURN -> return [148:8]
1107 | | |--EXPR -> EXPR [148:15]
1108 | | | `--IDENT -> lineStart [148:15]
1109 | | `--SEMI -> ; [148:24]
1110 | `--RCURLY -> } [149:4]
1111 |--METHOD_DEF -> METHOD_DEF [151:4]
1112 | |--MODIFIERS -> MODIFIERS [151:4]
1113 | | `--LITERAL_PRIVATE -> private [151:4]
1114 | |--TYPE -> TYPE [151:12]
1115 | | `--LITERAL_VOID -> void [151:12]
1116 | |--IDENT -> verifyWarns [151:17]
1117 | |--LPAREN -> ( [151:28]
1118 | |--PARAMETERS -> PARAMETERS [151:29]
1119 | | |--PARAMETER_DEF -> PARAMETER_DEF [151:29]
1120 | | | |--MODIFIERS -> MODIFIERS [151:29]
1121 | | | |--TYPE -> TYPE [151:29]
1122 | | | | `--IDENT -> Configuration [151:29]
1123 | | | `--IDENT -> config [151:43]
1124 | | |--COMMA -> , [151:49]
1125 | | |--PARAMETER_DEF -> PARAMETER_DEF [151:51]
1126 | | | |--MODIFIERS -> MODIFIERS [151:51]
1127 | | | |--TYPE -> TYPE [151:51]
1128 | | | | `--IDENT -> String [151:51]
1129 | | | `--IDENT -> filePath [151:58]
1130 | | |--COMMA -> , [151:66]
1131 | | `--PARAMETER_DEF -> PARAMETER_DEF [152:20]
1132 | | |--MODIFIERS -> MODIFIERS [152:20]
1133 | | |--TYPE -> TYPE [152:20]
1134 | | | `--IDENT -> String [152:20]
1135 | | |--ELLIPSIS -> ... [152:26]
1136 | | `--IDENT -> expected [152:30]
1137 | |--RPAREN -> ) [152:38]
1138 | |--LITERAL_THROWS -> throws [153:20]
1139 | | `--IDENT -> Exception [153:27]
1140 | `--SLIST -> { [153:37]
1141 | |--VARIABLE_DEF -> VARIABLE_DEF [154:8]
1142 | | |--MODIFIERS -> MODIFIERS [154:8]
1143 | | | `--FINAL -> final [154:8]
1144 | | |--TYPE -> TYPE [154:14]
1145 | | | `--LITERAL_INT -> int [154:14]
1146 | | |--IDENT -> tabWidth [154:18]
1147 | | `--ASSIGN -> = [154:27]
1148 | | `--EXPR -> EXPR [154:45]
1149 | | `--METHOD_CALL -> ( [154:45]
1150 | | |--DOT -> . [154:36]
1151 | | | |--IDENT -> Integer [154:29]
1152 | | | `--IDENT -> parseInt [154:37]
1153 | | |--ELIST -> ELIST [154:65]
1154 | | | `--EXPR -> EXPR [154:65]
1155 | | | `--METHOD_CALL -> ( [154:65]
1156 | | | |--DOT -> . [154:52]
1157 | | | | |--IDENT -> config [154:46]
1158 | | | | `--IDENT -> getAttribute [154:53]
1159 | | | |--ELIST -> ELIST [154:66]
1160 | | | | `--EXPR -> EXPR [154:66]
1161 | | | | `--STRING_LITERAL -> "tabWidth" [154:66]
1162 | | | `--RPAREN -> ) [154:76]
1163 | | `--RPAREN -> ) [154:77]
1164 | |--SEMI -> ; [154:78]
1165 | |--VARIABLE_DEF -> VARIABLE_DEF [155:8]
1166 | | |--MODIFIERS -> MODIFIERS [155:8]
1167 | | | `--FINAL -> final [155:8]
1168 | | |--TYPE -> TYPE [155:27]
1169 | | | `--ARRAY_DECLARATOR -> [ [155:27]
1170 | | | |--IDENT -> IndentComment [155:14]
1171 | | | `--RBRACK -> ] [155:28]
1172 | | |--IDENT -> linesWithWarn [155:30]
1173 | | `--ASSIGN -> = [155:44]
1174 | | `--EXPR -> EXPR [156:56]
1175 | | `--METHOD_CALL -> ( [156:56]
1176 | | |--IDENT -> getLinesWithWarnAndCheckComments [156:24]
1177 | | |--ELIST -> ELIST [156:57]
1178 | | | |--EXPR -> EXPR [156:57]
1179 | | | | `--IDENT -> filePath [156:57]
1180 | | | |--COMMA -> , [156:65]
1181 | | | `--EXPR -> EXPR [156:67]
1182 | | | `--IDENT -> tabWidth [156:67]
1183 | | `--RPAREN -> ) [156:75]
1184 | |--SEMI -> ; [156:76]
1185 | |--EXPR -> EXPR [157:14]
1186 | | `--METHOD_CALL -> ( [157:14]
1187 | | |--IDENT -> verify [157:8]
1188 | | |--ELIST -> ELIST [157:15]
1189 | | | |--EXPR -> EXPR [157:15]
1190 | | | | `--IDENT -> config [157:15]
1191 | | | |--COMMA -> , [157:21]
1192 | | | |--EXPR -> EXPR [157:23]
1193 | | | | `--IDENT -> filePath [157:23]
1194 | | | |--COMMA -> , [157:31]
1195 | | | |--EXPR -> EXPR [157:33]
1196 | | | | `--IDENT -> expected [157:33]
1197 | | | |--COMMA -> , [157:41]
1198 | | | `--EXPR -> EXPR [157:43]
1199 | | | `--IDENT -> linesWithWarn [157:43]
1200 | | `--RPAREN -> ) [157:56]
1201 | |--SEMI -> ; [157:57]
1202 | |--EXPR -> EXPR [158:20]
1203 | | `--METHOD_CALL -> ( [158:20]
1204 | | |--IDENT -> assertEquals [158:8]
1205 | | |--ELIST -> ELIST [158:34]
1206 | | | |--EXPR -> EXPR [158:34]
1207 | | | | `--DOT -> . [158:34]
1208 | | | | |--IDENT -> linesWithWarn [158:21]
1209 | | | | `--IDENT -> length [158:35]
1210 | | | |--COMMA -> , [158:41]
1211 | | | |--EXPR -> EXPR [158:51]
1212 | | | | `--DOT -> . [158:51]
1213 | | | | |--IDENT -> expected [158:43]
1214 | | | | `--IDENT -> length [158:52]
1215 | | | |--COMMA -> , [158:58]
1216 | | | `--EXPR -> EXPR [159:12]
1217 | | | `--STRING_LITERAL -> "Expected warning count in UT does not match warn comment count in input file" [159:12]
1218 | | `--RPAREN -> ) [159:90]
1219 | |--SEMI -> ; [159:91]
1220 | `--RCURLY -> } [160:4]
1221 |--METHOD_DEF -> METHOD_DEF [162:4]
1222 | |--MODIFIERS -> MODIFIERS [162:4]
1223 | | `--LITERAL_PRIVATE -> private [162:4]
1224 | |--TYPE -> TYPE [162:12]
1225 | | `--LITERAL_VOID -> void [162:12]
1226 | |--IDENT -> verify [162:17]
1227 | |--LPAREN -> ( [162:23]
1228 | |--PARAMETERS -> PARAMETERS [162:24]
1229 | | |--PARAMETER_DEF -> PARAMETER_DEF [162:24]
1230 | | | |--MODIFIERS -> MODIFIERS [162:24]
1231 | | | |--TYPE -> TYPE [162:24]
1232 | | | | `--IDENT -> Configuration [162:24]
1233 | | | `--IDENT -> config [162:38]
1234 | | |--COMMA -> , [162:44]
1235 | | |--PARAMETER_DEF -> PARAMETER_DEF [162:46]
1236 | | | |--MODIFIERS -> MODIFIERS [162:46]
1237 | | | |--TYPE -> TYPE [162:46]
1238 | | | | `--IDENT -> String [162:46]
1239 | | | `--IDENT -> filePath [162:53]
1240 | | |--COMMA -> , [162:61]
1241 | | |--PARAMETER_DEF -> PARAMETER_DEF [162:69]
1242 | | | |--MODIFIERS -> MODIFIERS [162:69]
1243 | | | |--TYPE -> TYPE [162:69]
1244 | | | | `--ARRAY_DECLARATOR -> [ [162:69]
1245 | | | | |--IDENT -> String [162:63]
1246 | | | | `--RBRACK -> ] [162:70]
1247 | | | `--IDENT -> expected [162:72]
1248 | | |--COMMA -> , [162:80]
1249 | | `--PARAMETER_DEF -> PARAMETER_DEF [163:12]
1250 | | |--MODIFIERS -> MODIFIERS [163:12]
1251 | | | `--FINAL -> final [163:12]
1252 | | |--TYPE -> TYPE [163:18]
1253 | | | `--IDENT -> IndentComment [163:18]
1254 | | |--ELLIPSIS -> ... [163:31]
1255 | | `--IDENT -> linesWithWarn [163:35]
1256 | |--RPAREN -> ) [163:48]
1257 | |--LITERAL_THROWS -> throws [163:50]
1258 | | `--IDENT -> Exception [163:57]
1259 | `--SLIST -> { [163:67]
1260 | |--VARIABLE_DEF -> VARIABLE_DEF [164:8]
1261 | | |--MODIFIERS -> MODIFIERS [164:8]
1262 | | | `--FINAL -> final [164:8]
1263 | | |--TYPE -> TYPE [164:14]
1264 | | | `--IDENT -> Checker [164:14]
1265 | | |--IDENT -> checker [164:22]
1266 | | `--ASSIGN -> = [164:30]
1267 | | `--EXPR -> EXPR [164:45]
1268 | | `--METHOD_CALL -> ( [164:45]
1269 | | |--IDENT -> createChecker [164:32]
1270 | | |--ELIST -> ELIST [164:46]
1271 | | | `--EXPR -> EXPR [164:46]
1272 | | | `--IDENT -> config [164:46]
1273 | | `--RPAREN -> ) [164:52]
1274 | |--SEMI -> ; [164:53]
1275 | |--EXPR -> EXPR [165:27]
1276 | | `--METHOD_CALL -> ( [165:27]
1277 | | |--DOT -> . [165:15]
1278 | | | |--IDENT -> checker [165:8]
1279 | | | `--IDENT -> addListener [165:16]
1280 | | |--ELIST -> ELIST [165:28]
1281 | | | `--EXPR -> EXPR [165:28]
1282 | | | `--LITERAL_NEW -> new [165:28]
1283 | | | |--IDENT -> IndentAudit [165:32]
1284 | | | |--LPAREN -> ( [165:43]
1285 | | | |--ELIST -> ELIST [165:44]
1286 | | | | `--EXPR -> EXPR [165:44]
1287 | | | | `--IDENT -> linesWithWarn [165:44]
1288 | | | `--RPAREN -> ) [165:57]
1289 | | `--RPAREN -> ) [165:58]
1290 | |--SEMI -> ; [165:59]
1291 | |--EXPR -> EXPR [166:14]
1292 | | `--METHOD_CALL -> ( [166:14]
1293 | | |--IDENT -> verify [166:8]
1294 | | |--ELIST -> ELIST [166:15]
1295 | | | |--EXPR -> EXPR [166:15]
1296 | | | | `--IDENT -> checker [166:15]
1297 | | | |--COMMA -> , [166:22]
1298 | | | |--EXPR -> EXPR [166:24]
1299 | | | | `--IDENT -> filePath [166:24]
1300 | | | |--COMMA -> , [166:32]
1301 | | | `--EXPR -> EXPR [166:34]
1302 | | | `--IDENT -> expected [166:34]
1303 | | `--RPAREN -> ) [166:42]
1304 | |--SEMI -> ; [166:43]
1305 | `--RCURLY -> } [167:4]
1306 |--METHOD_DEF -> METHOD_DEF [169:4]
1307 | |--MODIFIERS -> MODIFIERS [169:4]
1308 | | |--ANNOTATION -> ANNOTATION [169:4]
1309 | | | |--AT -> @ [169:4]
1310 | | | `--IDENT -> Override [169:5]
1311 | | `--LITERAL_PROTECTED -> protected [170:4]
1312 | |--TYPE -> TYPE [170:14]
1313 | | `--IDENT -> String [170:14]
1314 | |--IDENT -> getPackageLocation [170:21]
1315 | |--LPAREN -> ( [170:39]
1316 | |--PARAMETERS -> PARAMETERS [170:40]
1317 | |--RPAREN -> ) [170:40]
1318 | `--SLIST -> { [170:42]
1319 | |--LITERAL_RETURN -> return [171:8]
1320 | | |--EXPR -> EXPR [171:15]
1321 | | | `--STRING_LITERAL -> "com/puppycrawl/tools/checkstyle/checks/indentation/indentation" [171:15]
1322 | | `--SEMI -> ; [171:79]
1323 | `--RCURLY -> } [172:4]
1324 |--METHOD_DEF -> METHOD_DEF [174:4]
1325 | |--MODIFIERS -> MODIFIERS [174:4]
1326 | | |--ANNOTATION -> ANNOTATION [174:4]
1327 | | | |--AT -> @ [174:4]
1328 | | | `--IDENT -> Test [174:5]
1329 | | `--LITERAL_PUBLIC -> public [175:4]
1330 | |--TYPE -> TYPE [175:11]
1331 | | `--LITERAL_VOID -> void [175:11]
1332 | |--IDENT -> testGetRequiredTokens [175:16]
1333 | |--LPAREN -> ( [175:37]
1334 | |--PARAMETERS -> PARAMETERS [175:38]
1335 | |--RPAREN -> ) [175:38]
1336 | `--SLIST -> { [175:40]
1337 | |--VARIABLE_DEF -> VARIABLE_DEF [176:8]
1338 | | |--MODIFIERS -> MODIFIERS [176:8]
1339 | | | `--FINAL -> final [176:8]
1340 | | |--TYPE -> TYPE [176:14]
1341 | | | `--IDENT -> IndentationCheck [176:14]
1342 | | |--IDENT -> checkObj [176:31]
1343 | | `--ASSIGN -> = [176:40]
1344 | | `--EXPR -> EXPR [176:42]
1345 | | `--LITERAL_NEW -> new [176:42]
1346 | | |--IDENT -> IndentationCheck [176:46]
1347 | | |--LPAREN -> ( [176:62]
1348 | | |--ELIST -> ELIST [176:63]
1349 | | `--RPAREN -> ) [176:63]
1350 | |--SEMI -> ; [176:64]
1351 | |--VARIABLE_DEF -> VARIABLE_DEF [177:8]
1352 | | |--MODIFIERS -> MODIFIERS [177:8]
1353 | | | `--FINAL -> final [177:8]
1354 | | |--TYPE -> TYPE [177:14]
1355 | | | |--LITERAL_INT -> int [177:14]
1356 | | | `--ARRAY_DECLARATOR -> [ [177:17]
1357 | | | `--RBRACK -> ] [177:18]
1358 | | |--IDENT -> requiredTokens [177:20]
1359 | | `--ASSIGN -> = [177:35]
1360 | | `--EXPR -> EXPR [177:63]
1361 | | `--METHOD_CALL -> ( [177:63]
1362 | | |--DOT -> . [177:45]
1363 | | | |--IDENT -> checkObj [177:37]
1364 | | | `--IDENT -> getRequiredTokens [177:46]
1365 | | |--ELIST -> ELIST [177:64]
1366 | | `--RPAREN -> ) [177:64]
1367 | |--SEMI -> ; [177:65]
1368 | |--VARIABLE_DEF -> VARIABLE_DEF [178:8]
1369 | | |--MODIFIERS -> MODIFIERS [178:8]
1370 | | | `--FINAL -> final [178:8]
1371 | | |--TYPE -> TYPE [178:14]
1372 | | | `--IDENT -> HandlerFactory [178:14]
1373 | | |--IDENT -> handlerFactory [178:29]
1374 | | `--ASSIGN -> = [178:44]
1375 | | `--EXPR -> EXPR [178:46]
1376 | | `--LITERAL_NEW -> new [178:46]
1377 | | |--IDENT -> HandlerFactory [178:50]
1378 | | |--LPAREN -> ( [178:64]
1379 | | |--ELIST -> ELIST [178:65]
1380 | | `--RPAREN -> ) [178:65]
1381 | |--SEMI -> ; [178:66]
1382 | |--VARIABLE_DEF -> VARIABLE_DEF [179:8]
1383 | | |--MODIFIERS -> MODIFIERS [179:8]
1384 | | | `--FINAL -> final [179:8]
1385 | | |--TYPE -> TYPE [179:14]
1386 | | | |--LITERAL_INT -> int [179:14]
1387 | | | `--ARRAY_DECLARATOR -> [ [179:17]
1388 | | | `--RBRACK -> ] [179:18]
1389 | | |--IDENT -> expected [179:20]
1390 | | `--ASSIGN -> = [179:29]
1391 | | `--EXPR -> EXPR [179:61]
1392 | | `--METHOD_CALL -> ( [179:61]
1393 | | |--DOT -> . [179:45]
1394 | | | |--IDENT -> handlerFactory [179:31]
1395 | | | `--IDENT -> getHandledTypes [179:46]
1396 | | |--ELIST -> ELIST [179:62]
1397 | | `--RPAREN -> ) [179:62]
1398 | |--SEMI -> ; [179:63]
1399 | |--EXPR -> EXPR [180:19]
1400 | | `--METHOD_CALL -> ( [180:19]
1401 | | |--DOT -> . [180:14]
1402 | | | |--IDENT -> Arrays [180:8]
1403 | | | `--IDENT -> sort [180:15]
1404 | | |--ELIST -> ELIST [180:20]
1405 | | | `--EXPR -> EXPR [180:20]
1406 | | | `--IDENT -> expected [180:20]
1407 | | `--RPAREN -> ) [180:28]
1408 | |--SEMI -> ; [180:29]
1409 | |--EXPR -> EXPR [181:19]
1410 | | `--METHOD_CALL -> ( [181:19]
1411 | | |--DOT -> . [181:14]
1412 | | | |--IDENT -> Arrays [181:8]
1413 | | | `--IDENT -> sort [181:15]
1414 | | |--ELIST -> ELIST [181:20]
1415 | | | `--EXPR -> EXPR [181:20]
1416 | | | `--IDENT -> requiredTokens [181:20]
1417 | | `--RPAREN -> ) [181:34]
1418 | |--SEMI -> ; [181:35]
1419 | |--EXPR -> EXPR [182:25]
1420 | | `--METHOD_CALL -> ( [182:25]
1421 | | |--IDENT -> assertArrayEquals [182:8]
1422 | | |--ELIST -> ELIST [182:26]
1423 | | | |--EXPR -> EXPR [182:26]
1424 | | | | `--IDENT -> expected [182:26]
1425 | | | |--COMMA -> , [182:34]
1426 | | | |--EXPR -> EXPR [182:36]
1427 | | | | `--IDENT -> requiredTokens [182:36]
1428 | | | |--COMMA -> , [182:50]
1429 | | | `--EXPR -> EXPR [182:52]
1430 | | | `--STRING_LITERAL -> "Default required tokens are invalid" [182:52]
1431 | | `--RPAREN -> ) [182:89]
1432 | |--SEMI -> ; [182:90]
1433 | `--RCURLY -> } [183:4]
1434 |--METHOD_DEF -> METHOD_DEF [185:4]
1435 | |--MODIFIERS -> MODIFIERS [185:4]
1436 | | |--ANNOTATION -> ANNOTATION [185:4]
1437 | | | |--AT -> @ [185:4]
1438 | | | `--IDENT -> Test [185:5]
1439 | | `--LITERAL_PUBLIC -> public [186:4]
1440 | |--TYPE -> TYPE [186:11]
1441 | | `--LITERAL_VOID -> void [186:11]
1442 | |--IDENT -> testGetAcceptableTokens [186:16]
1443 | |--LPAREN -> ( [186:39]
1444 | |--PARAMETERS -> PARAMETERS [186:40]
1445 | |--RPAREN -> ) [186:40]
1446 | `--SLIST -> { [186:42]
1447 | |--VARIABLE_DEF -> VARIABLE_DEF [187:8]
1448 | | |--MODIFIERS -> MODIFIERS [187:8]
1449 | | | `--FINAL -> final [187:8]
1450 | | |--TYPE -> TYPE [187:14]
1451 | | | `--IDENT -> IndentationCheck [187:14]
1452 | | |--IDENT -> checkObj [187:31]
1453 | | `--ASSIGN -> = [187:40]
1454 | | `--EXPR -> EXPR [187:42]
1455 | | `--LITERAL_NEW -> new [187:42]
1456 | | |--IDENT -> IndentationCheck [187:46]
1457 | | |--LPAREN -> ( [187:62]
1458 | | |--ELIST -> ELIST [187:63]
1459 | | `--RPAREN -> ) [187:63]
1460 | |--SEMI -> ; [187:64]
1461 | |--VARIABLE_DEF -> VARIABLE_DEF [188:8]
1462 | | |--MODIFIERS -> MODIFIERS [188:8]
1463 | | | `--FINAL -> final [188:8]
1464 | | |--TYPE -> TYPE [188:14]
1465 | | | |--LITERAL_INT -> int [188:14]
1466 | | | `--ARRAY_DECLARATOR -> [ [188:17]
1467 | | | `--RBRACK -> ] [188:18]
1468 | | |--IDENT -> acceptableTokens [188:20]
1469 | | `--ASSIGN -> = [188:37]
1470 | | `--EXPR -> EXPR [188:67]
1471 | | `--METHOD_CALL -> ( [188:67]
1472 | | |--DOT -> . [188:47]
1473 | | | |--IDENT -> checkObj [188:39]
1474 | | | `--IDENT -> getAcceptableTokens [188:48]
1475 | | |--ELIST -> ELIST [188:68]
1476 | | `--RPAREN -> ) [188:68]
1477 | |--SEMI -> ; [188:69]
1478 | |--VARIABLE_DEF -> VARIABLE_DEF [189:8]
1479 | | |--MODIFIERS -> MODIFIERS [189:8]
1480 | | | `--FINAL -> final [189:8]
1481 | | |--TYPE -> TYPE [189:14]
1482 | | | `--IDENT -> HandlerFactory [189:14]
1483 | | |--IDENT -> handlerFactory [189:29]
1484 | | `--ASSIGN -> = [189:44]
1485 | | `--EXPR -> EXPR [189:46]
1486 | | `--LITERAL_NEW -> new [189:46]
1487 | | |--IDENT -> HandlerFactory [189:50]
1488 | | |--LPAREN -> ( [189:64]
1489 | | |--ELIST -> ELIST [189:65]
1490 | | `--RPAREN -> ) [189:65]
1491 | |--SEMI -> ; [189:66]
1492 | |--VARIABLE_DEF -> VARIABLE_DEF [190:8]
1493 | | |--MODIFIERS -> MODIFIERS [190:8]
1494 | | | `--FINAL -> final [190:8]
1495 | | |--TYPE -> TYPE [190:14]
1496 | | | |--LITERAL_INT -> int [190:14]
1497 | | | `--ARRAY_DECLARATOR -> [ [190:17]
1498 | | | `--RBRACK -> ] [190:18]
1499 | | |--IDENT -> expected [190:20]
1500 | | `--ASSIGN -> = [190:29]
1501 | | `--EXPR -> EXPR [190:61]
1502 | | `--METHOD_CALL -> ( [190:61]
1503 | | |--DOT -> . [190:45]
1504 | | | |--IDENT -> handlerFactory [190:31]
1505 | | | `--IDENT -> getHandledTypes [190:46]
1506 | | |--ELIST -> ELIST [190:62]
1507 | | `--RPAREN -> ) [190:62]
1508 | |--SEMI -> ; [190:63]
1509 | |--EXPR -> EXPR [191:19]
1510 | | `--METHOD_CALL -> ( [191:19]
1511 | | |--DOT -> . [191:14]
1512 | | | |--IDENT -> Arrays [191:8]
1513 | | | `--IDENT -> sort [191:15]
1514 | | |--ELIST -> ELIST [191:20]
1515 | | | `--EXPR -> EXPR [191:20]
1516 | | | `--IDENT -> expected [191:20]
1517 | | `--RPAREN -> ) [191:28]
1518 | |--SEMI -> ; [191:29]
1519 | |--EXPR -> EXPR [192:19]
1520 | | `--METHOD_CALL -> ( [192:19]
1521 | | |--DOT -> . [192:14]
1522 | | | |--IDENT -> Arrays [192:8]
1523 | | | `--IDENT -> sort [192:15]
1524 | | |--ELIST -> ELIST [192:20]
1525 | | | `--EXPR -> EXPR [192:20]
1526 | | | `--IDENT -> acceptableTokens [192:20]
1527 | | `--RPAREN -> ) [192:36]
1528 | |--SEMI -> ; [192:37]
1529 | |--EXPR -> EXPR [193:25]
1530 | | `--METHOD_CALL -> ( [193:25]
1531 | | |--IDENT -> assertArrayEquals [193:8]
1532 | | |--ELIST -> ELIST [193:26]
1533 | | | |--EXPR -> EXPR [193:26]
1534 | | | | `--IDENT -> expected [193:26]
1535 | | | |--COMMA -> , [193:34]
1536 | | | |--EXPR -> EXPR [193:36]
1537 | | | | `--IDENT -> acceptableTokens [193:36]
1538 | | | |--COMMA -> , [193:52]
1539 | | | `--EXPR -> EXPR [193:54]
1540 | | | `--STRING_LITERAL -> "Default acceptable tokens are invalid" [193:54]
1541 | | `--RPAREN -> ) [193:93]
1542 | |--SEMI -> ; [193:94]
1543 | `--RCURLY -> } [194:4]
1544 |--METHOD_DEF -> METHOD_DEF [196:4]
1545 | |--MODIFIERS -> MODIFIERS [196:4]
1546 | | |--ANNOTATION -> ANNOTATION [196:4]
1547 | | | |--AT -> @ [196:4]
1548 | | | `--IDENT -> Test [196:5]
1549 | | `--LITERAL_PUBLIC -> public [197:4]
1550 | |--TYPE -> TYPE [197:11]
1551 | | `--LITERAL_VOID -> void [197:11]
1552 | |--IDENT -> testThrowsIndentProperty [197:16]
1553 | |--LPAREN -> ( [197:40]
1554 | |--PARAMETERS -> PARAMETERS [197:41]
1555 | |--RPAREN -> ) [197:41]
1556 | `--SLIST -> { [197:43]
1557 | |--VARIABLE_DEF -> VARIABLE_DEF [198:8]
1558 | | |--MODIFIERS -> MODIFIERS [198:8]
1559 | | | `--FINAL -> final [198:8]
1560 | | |--TYPE -> TYPE [198:14]
1561 | | | `--IDENT -> IndentationCheck [198:14]
1562 | | |--IDENT -> indentationCheck [198:31]
1563 | | `--ASSIGN -> = [198:48]
1564 | | `--EXPR -> EXPR [198:50]
1565 | | `--LITERAL_NEW -> new [198:50]
1566 | | |--IDENT -> IndentationCheck [198:54]
1567 | | |--LPAREN -> ( [198:70]
1568 | | |--ELIST -> ELIST [198:71]
1569 | | `--RPAREN -> ) [198:71]
1570 | |--SEMI -> ; [198:72]
1571 | |--EXPR -> EXPR [200:40]
1572 | | `--METHOD_CALL -> ( [200:40]
1573 | | |--DOT -> . [200:24]
1574 | | | |--IDENT -> indentationCheck [200:8]
1575 | | | `--IDENT -> setThrowsIndent [200:25]
1576 | | |--ELIST -> ELIST [200:41]
1577 | | | `--EXPR -> EXPR [200:41]
1578 | | | `--NUM_INT -> 1 [200:41]
1579 | | `--RPAREN -> ) [200:42]
1580 | |--SEMI -> ; [200:43]
1581 | |--EXPR -> EXPR [202:20]
1582 | | `--METHOD_CALL -> ( [202:20]
1583 | | |--IDENT -> assertEquals [202:8]
1584 | | |--ELIST -> ELIST [202:21]
1585 | | | |--EXPR -> EXPR [202:21]
1586 | | | | `--NUM_INT -> 1 [202:21]
1587 | | | |--COMMA -> , [202:22]
1588 | | | |--EXPR -> EXPR [202:56]
1589 | | | | `--METHOD_CALL -> ( [202:56]
1590 | | | | |--DOT -> . [202:40]
1591 | | | | | |--IDENT -> indentationCheck [202:24]
1592 | | | | | `--IDENT -> getThrowsIndent [202:41]
1593 | | | | |--ELIST -> ELIST [202:57]
1594 | | | | `--RPAREN -> ) [202:57]
1595 | | | |--COMMA -> , [202:58]
1596 | | | `--EXPR -> EXPR [202:60]
1597 | | | `--STRING_LITERAL -> "Invalid throws indent" [202:60]
1598 | | `--RPAREN -> ) [202:83]
1599 | |--SEMI -> ; [202:84]
1600 | `--RCURLY -> } [203:4]
1601 |--METHOD_DEF -> METHOD_DEF [205:4]
1602 | |--MODIFIERS -> MODIFIERS [205:4]
1603 | | |--ANNOTATION -> ANNOTATION [205:4]
1604 | | | |--AT -> @ [205:4]
1605 | | | `--IDENT -> Test [205:5]
1606 | | `--LITERAL_PUBLIC -> public [206:4]
1607 | |--TYPE -> TYPE [206:11]
1608 | | `--LITERAL_VOID -> void [206:11]
1609 | |--IDENT -> testStrictCondition [206:16]
1610 | |--LPAREN -> ( [206:35]
1611 | |--PARAMETERS -> PARAMETERS [206:36]
1612 | |--RPAREN -> ) [206:36]
1613 | |--LITERAL_THROWS -> throws [206:38]
1614 | | `--IDENT -> Exception [206:45]
1615 | `--SLIST -> { [206:55]
1616 | |--VARIABLE_DEF -> VARIABLE_DEF [207:8]
1617 | | |--MODIFIERS -> MODIFIERS [207:8]
1618 | | | `--FINAL -> final [207:8]
1619 | | |--TYPE -> TYPE [207:14]
1620 | | | `--IDENT -> DefaultConfiguration [207:14]
1621 | | |--IDENT -> checkConfig [207:35]
1622 | | `--ASSIGN -> = [207:47]
1623 | | `--EXPR -> EXPR [207:67]
1624 | | `--METHOD_CALL -> ( [207:67]
1625 | | |--IDENT -> createModuleConfig [207:49]
1626 | | |--ELIST -> ELIST [207:84]
1627 | | | `--EXPR -> EXPR [207:84]
1628 | | | `--DOT -> . [207:84]
1629 | | | |--IDENT -> IndentationCheck [207:68]
1630 | | | `--LITERAL_CLASS -> class [207:85]
1631 | | `--RPAREN -> ) [207:90]
1632 | |--SEMI -> ; [207:91]
1633 | |--EXPR -> EXPR [208:32]
1634 | | `--METHOD_CALL -> ( [208:32]
1635 | | |--DOT -> . [208:19]
1636 | | | |--IDENT -> checkConfig [208:8]
1637 | | | `--IDENT -> addAttribute [208:20]
1638 | | |--ELIST -> ELIST [208:33]
1639 | | | |--EXPR -> EXPR [208:33]
1640 | | | | `--STRING_LITERAL -> "arrayInitIndent" [208:33]
1641 | | | |--COMMA -> , [208:50]
1642 | | | `--EXPR -> EXPR [208:52]
1643 | | | `--STRING_LITERAL -> "4" [208:52]
1644 | | `--RPAREN -> ) [208:55]
1645 | |--SEMI -> ; [208:56]
1646 | |--EXPR -> EXPR [209:32]
1647 | | `--METHOD_CALL -> ( [209:32]
1648 | | |--DOT -> . [209:19]
1649 | | | |--IDENT -> checkConfig [209:8]
1650 | | | `--IDENT -> addAttribute [209:20]
1651 | | |--ELIST -> ELIST [209:33]
1652 | | | |--EXPR -> EXPR [209:33]
1653 | | | | `--STRING_LITERAL -> "basicOffset" [209:33]
1654 | | | |--COMMA -> , [209:46]
1655 | | | `--EXPR -> EXPR [209:48]
1656 | | | `--STRING_LITERAL -> "4" [209:48]
1657 | | `--RPAREN -> ) [209:51]
1658 | |--SEMI -> ; [209:52]
1659 | |--EXPR -> EXPR [210:32]
1660 | | `--METHOD_CALL -> ( [210:32]
1661 | | |--DOT -> . [210:19]
1662 | | | |--IDENT -> checkConfig [210:8]
1663 | | | `--IDENT -> addAttribute [210:20]
1664 | | |--ELIST -> ELIST [210:33]
1665 | | | |--EXPR -> EXPR [210:33]
1666 | | | | `--STRING_LITERAL -> "braceAdjustment" [210:33]
1667 | | | |--COMMA -> , [210:50]
1668 | | | `--EXPR -> EXPR [210:52]
1669 | | | `--STRING_LITERAL -> "4" [210:52]
1670 | | `--RPAREN -> ) [210:55]
1671 | |--SEMI -> ; [210:56]
1672 | |--EXPR -> EXPR [211:32]
1673 | | `--METHOD_CALL -> ( [211:32]
1674 | | |--DOT -> . [211:19]
1675 | | | |--IDENT -> checkConfig [211:8]
1676 | | | `--IDENT -> addAttribute [211:20]
1677 | | |--ELIST -> ELIST [211:33]
1678 | | | |--EXPR -> EXPR [211:33]
1679 | | | | `--STRING_LITERAL -> "caseIndent" [211:33]
1680 | | | |--COMMA -> , [211:45]
1681 | | | `--EXPR -> EXPR [211:47]
1682 | | | `--STRING_LITERAL -> "4" [211:47]
1683 | | `--RPAREN -> ) [211:50]
1684 | |--SEMI -> ; [211:51]
1685 | |--EXPR -> EXPR [212:32]
1686 | | `--METHOD_CALL -> ( [212:32]
1687 | | |--DOT -> . [212:19]
1688 | | | |--IDENT -> checkConfig [212:8]
1689 | | | `--IDENT -> addAttribute [212:20]
1690 | | |--ELIST -> ELIST [212:33]
1691 | | | |--EXPR -> EXPR [212:33]
1692 | | | | `--STRING_LITERAL -> "forceStrictCondition" [212:33]
1693 | | | |--COMMA -> , [212:55]
1694 | | | `--EXPR -> EXPR [212:57]
1695 | | | `--STRING_LITERAL -> "true" [212:57]
1696 | | `--RPAREN -> ) [212:63]
1697 | |--SEMI -> ; [212:64]
1698 | |--EXPR -> EXPR [213:32]
1699 | | `--METHOD_CALL -> ( [213:32]
1700 | | |--DOT -> . [213:19]
1701 | | | |--IDENT -> checkConfig [213:8]
1702 | | | `--IDENT -> addAttribute [213:20]
1703 | | |--ELIST -> ELIST [213:33]
1704 | | | |--EXPR -> EXPR [213:33]
1705 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [213:33]
1706 | | | |--COMMA -> , [213:58]
1707 | | | `--EXPR -> EXPR [213:60]
1708 | | | `--STRING_LITERAL -> "8" [213:60]
1709 | | `--RPAREN -> ) [213:63]
1710 | |--SEMI -> ; [213:64]
1711 | |--EXPR -> EXPR [214:32]
1712 | | `--METHOD_CALL -> ( [214:32]
1713 | | |--DOT -> . [214:19]
1714 | | | |--IDENT -> checkConfig [214:8]
1715 | | | `--IDENT -> addAttribute [214:20]
1716 | | |--ELIST -> ELIST [214:33]
1717 | | | |--EXPR -> EXPR [214:33]
1718 | | | | `--STRING_LITERAL -> "tabWidth" [214:33]
1719 | | | |--COMMA -> , [214:43]
1720 | | | `--EXPR -> EXPR [214:45]
1721 | | | `--STRING_LITERAL -> "4" [214:45]
1722 | | `--RPAREN -> ) [214:48]
1723 | |--SEMI -> ; [214:49]
1724 | |--EXPR -> EXPR [215:32]
1725 | | `--METHOD_CALL -> ( [215:32]
1726 | | |--DOT -> . [215:19]
1727 | | | |--IDENT -> checkConfig [215:8]
1728 | | | `--IDENT -> addAttribute [215:20]
1729 | | |--ELIST -> ELIST [215:33]
1730 | | | |--EXPR -> EXPR [215:33]
1731 | | | | `--STRING_LITERAL -> "throwsIndent" [215:33]
1732 | | | |--COMMA -> , [215:47]
1733 | | | `--EXPR -> EXPR [215:49]
1734 | | | `--STRING_LITERAL -> "8" [215:49]
1735 | | `--RPAREN -> ) [215:52]
1736 | |--SEMI -> ; [215:53]
1737 | |--VARIABLE_DEF -> VARIABLE_DEF [216:8]
1738 | | |--MODIFIERS -> MODIFIERS [216:8]
1739 | | | `--FINAL -> final [216:8]
1740 | | |--TYPE -> TYPE [216:20]
1741 | | | `--ARRAY_DECLARATOR -> [ [216:20]
1742 | | | |--IDENT -> String [216:14]
1743 | | | `--RBRACK -> ] [216:21]
1744 | | |--IDENT -> expected [216:23]
1745 | | `--ASSIGN -> = [216:32]
1746 | | `--ARRAY_INIT -> { [216:34]
1747 | | |--EXPR -> EXPR [217:22]
1748 | | | `--PLUS -> + [217:22]
1749 | | | |--STRING_LITERAL -> "10:29: " [217:12]
1750 | | | `--METHOD_CALL -> ( [217:39]
1751 | | | |--IDENT -> getCheckMessage [217:24]
1752 | | | |--ELIST -> ELIST [217:40]
1753 | | | | |--EXPR -> EXPR [217:40]
1754 | | | | | `--IDENT -> MSG_ERROR_MULTI [217:40]
1755 | | | | |--COMMA -> , [217:55]
1756 | | | | |--EXPR -> EXPR [217:57]
1757 | | | | | `--STRING_LITERAL -> "method def rcurly" [217:57]
1758 | | | | |--COMMA -> , [217:76]
1759 | | | | |--EXPR -> EXPR [217:78]
1760 | | | | | `--NUM_INT -> 28 [217:78]
1761 | | | | |--COMMA -> , [217:80]
1762 | | | | `--EXPR -> EXPR [217:82]
1763 | | | | `--STRING_LITERAL -> "16, 20, 24" [217:82]
1764 | | | `--RPAREN -> ) [217:94]
1765 | | |--COMMA -> , [217:95]
1766 | | |--EXPR -> EXPR [218:21]
1767 | | | `--PLUS -> + [218:21]
1768 | | | |--STRING_LITERAL -> "13:9: " [218:12]
1769 | | | `--METHOD_CALL -> ( [218:38]
1770 | | | |--IDENT -> getCheckMessage [218:23]
1771 | | | |--ELIST -> ELIST [218:39]
1772 | | | | |--EXPR -> EXPR [218:39]
1773 | | | | | `--IDENT -> MSG_ERROR [218:39]
1774 | | | | |--COMMA -> , [218:48]
1775 | | | | |--EXPR -> EXPR [218:50]
1776 | | | | | `--STRING_LITERAL -> "method def rcurly" [218:50]
1777 | | | | |--COMMA -> , [218:69]
1778 | | | | |--EXPR -> EXPR [218:71]
1779 | | | | | `--NUM_INT -> 8 [218:71]
1780 | | | | |--COMMA -> , [218:72]
1781 | | | | `--EXPR -> EXPR [218:74]
1782 | | | | `--NUM_INT -> 4 [218:74]
1783 | | | `--RPAREN -> ) [218:75]
1784 | | |--COMMA -> , [218:76]
1785 | | |--EXPR -> EXPR [219:21]
1786 | | | `--PLUS -> + [219:21]
1787 | | | |--STRING_LITERAL -> "14:5: " [219:12]
1788 | | | `--METHOD_CALL -> ( [219:38]
1789 | | | |--IDENT -> getCheckMessage [219:23]
1790 | | | |--ELIST -> ELIST [219:39]
1791 | | | | |--EXPR -> EXPR [219:39]
1792 | | | | | `--IDENT -> MSG_ERROR [219:39]
1793 | | | | |--COMMA -> , [219:48]
1794 | | | | |--EXPR -> EXPR [219:50]
1795 | | | | | `--STRING_LITERAL -> "class def rcurly" [219:50]
1796 | | | | |--COMMA -> , [219:68]
1797 | | | | |--EXPR -> EXPR [219:70]
1798 | | | | | `--NUM_INT -> 4 [219:70]
1799 | | | | |--COMMA -> , [219:71]
1800 | | | | `--EXPR -> EXPR [219:73]
1801 | | | | `--NUM_INT -> 0 [219:73]
1802 | | | `--RPAREN -> ) [219:74]
1803 | | |--COMMA -> , [219:75]
1804 | | `--RCURLY -> } [220:8]
1805 | |--SEMI -> ; [220:9]
1806 | |--EXPR -> EXPR [221:19]
1807 | | `--METHOD_CALL -> ( [221:19]
1808 | | |--IDENT -> verifyWarns [221:8]
1809 | | |--ELIST -> ELIST [221:20]
1810 | | | |--EXPR -> EXPR [221:20]
1811 | | | | `--IDENT -> checkConfig [221:20]
1812 | | | |--COMMA -> , [221:31]
1813 | | | |--EXPR -> EXPR [221:40]
1814 | | | | `--METHOD_CALL -> ( [221:40]
1815 | | | | |--IDENT -> getPath [221:33]
1816 | | | | |--ELIST -> ELIST [221:41]
1817 | | | | | `--EXPR -> EXPR [221:41]
1818 | | | | | `--STRING_LITERAL -> "InputIndentationStrictCondition.java" [221:41]
1819 | | | | `--RPAREN -> ) [221:79]
1820 | | | |--COMMA -> , [221:80]
1821 | | | `--EXPR -> EXPR [221:82]
1822 | | | `--IDENT -> expected [221:82]
1823 | | `--RPAREN -> ) [221:90]
1824 | |--SEMI -> ; [221:91]
1825 | `--RCURLY -> } [222:4]
1826 |--METHOD_DEF -> METHOD_DEF [224:4]
1827 | |--MODIFIERS -> MODIFIERS [224:4]
1828 | | |--ANNOTATION -> ANNOTATION [224:4]
1829 | | | |--AT -> @ [224:4]
1830 | | | `--IDENT -> Test [224:5]
1831 | | `--LITERAL_PUBLIC -> public [225:4]
1832 | |--TYPE -> TYPE [225:11]
1833 | | `--LITERAL_VOID -> void [225:11]
1834 | |--IDENT -> forbidOldStyle [225:16]
1835 | |--LPAREN -> ( [225:30]
1836 | |--PARAMETERS -> PARAMETERS [225:31]
1837 | |--RPAREN -> ) [225:31]
1838 | |--LITERAL_THROWS -> throws [225:33]
1839 | | `--IDENT -> Exception [225:40]
1840 | `--SLIST -> { [225:50]
1841 | |--VARIABLE_DEF -> VARIABLE_DEF [226:8]
1842 | | |--MODIFIERS -> MODIFIERS [226:8]
1843 | | | `--FINAL -> final [226:8]
1844 | | |--TYPE -> TYPE [226:14]
1845 | | | `--IDENT -> DefaultConfiguration [226:14]
1846 | | |--IDENT -> checkConfig [226:35]
1847 | | `--ASSIGN -> = [226:47]
1848 | | `--EXPR -> EXPR [226:67]
1849 | | `--METHOD_CALL -> ( [226:67]
1850 | | |--IDENT -> createModuleConfig [226:49]
1851 | | |--ELIST -> ELIST [226:84]
1852 | | | `--EXPR -> EXPR [226:84]
1853 | | | `--DOT -> . [226:84]
1854 | | | |--IDENT -> IndentationCheck [226:68]
1855 | | | `--LITERAL_CLASS -> class [226:85]
1856 | | `--RPAREN -> ) [226:90]
1857 | |--SEMI -> ; [226:91]
1858 | |--EXPR -> EXPR [227:32]
1859 | | `--METHOD_CALL -> ( [227:32]
1860 | | |--DOT -> . [227:19]
1861 | | | |--IDENT -> checkConfig [227:8]
1862 | | | `--IDENT -> addAttribute [227:20]
1863 | | |--ELIST -> ELIST [227:33]
1864 | | | |--EXPR -> EXPR [227:33]
1865 | | | | `--STRING_LITERAL -> "arrayInitIndent" [227:33]
1866 | | | |--COMMA -> , [227:50]
1867 | | | `--EXPR -> EXPR [227:52]
1868 | | | `--STRING_LITERAL -> "4" [227:52]
1869 | | `--RPAREN -> ) [227:55]
1870 | |--SEMI -> ; [227:56]
1871 | |--EXPR -> EXPR [228:32]
1872 | | `--METHOD_CALL -> ( [228:32]
1873 | | |--DOT -> . [228:19]
1874 | | | |--IDENT -> checkConfig [228:8]
1875 | | | `--IDENT -> addAttribute [228:20]
1876 | | |--ELIST -> ELIST [228:33]
1877 | | | |--EXPR -> EXPR [228:33]
1878 | | | | `--STRING_LITERAL -> "basicOffset" [228:33]
1879 | | | |--COMMA -> , [228:46]
1880 | | | `--EXPR -> EXPR [228:48]
1881 | | | `--STRING_LITERAL -> "4" [228:48]
1882 | | `--RPAREN -> ) [228:51]
1883 | |--SEMI -> ; [228:52]
1884 | |--EXPR -> EXPR [229:32]
1885 | | `--METHOD_CALL -> ( [229:32]
1886 | | |--DOT -> . [229:19]
1887 | | | |--IDENT -> checkConfig [229:8]
1888 | | | `--IDENT -> addAttribute [229:20]
1889 | | |--ELIST -> ELIST [229:33]
1890 | | | |--EXPR -> EXPR [229:33]
1891 | | | | `--STRING_LITERAL -> "braceAdjustment" [229:33]
1892 | | | |--COMMA -> , [229:50]
1893 | | | `--EXPR -> EXPR [229:52]
1894 | | | `--STRING_LITERAL -> "0" [229:52]
1895 | | `--RPAREN -> ) [229:55]
1896 | |--SEMI -> ; [229:56]
1897 | |--EXPR -> EXPR [230:32]
1898 | | `--METHOD_CALL -> ( [230:32]
1899 | | |--DOT -> . [230:19]
1900 | | | |--IDENT -> checkConfig [230:8]
1901 | | | `--IDENT -> addAttribute [230:20]
1902 | | |--ELIST -> ELIST [230:33]
1903 | | | |--EXPR -> EXPR [230:33]
1904 | | | | `--STRING_LITERAL -> "caseIndent" [230:33]
1905 | | | |--COMMA -> , [230:45]
1906 | | | `--EXPR -> EXPR [230:47]
1907 | | | `--STRING_LITERAL -> "4" [230:47]
1908 | | `--RPAREN -> ) [230:50]
1909 | |--SEMI -> ; [230:51]
1910 | |--EXPR -> EXPR [231:32]
1911 | | `--METHOD_CALL -> ( [231:32]
1912 | | |--DOT -> . [231:19]
1913 | | | |--IDENT -> checkConfig [231:8]
1914 | | | `--IDENT -> addAttribute [231:20]
1915 | | |--ELIST -> ELIST [231:33]
1916 | | | |--EXPR -> EXPR [231:33]
1917 | | | | `--STRING_LITERAL -> "forceStrictCondition" [231:33]
1918 | | | |--COMMA -> , [231:55]
1919 | | | `--EXPR -> EXPR [231:57]
1920 | | | `--STRING_LITERAL -> "true" [231:57]
1921 | | `--RPAREN -> ) [231:63]
1922 | |--SEMI -> ; [231:64]
1923 | |--EXPR -> EXPR [232:32]
1924 | | `--METHOD_CALL -> ( [232:32]
1925 | | |--DOT -> . [232:19]
1926 | | | |--IDENT -> checkConfig [232:8]
1927 | | | `--IDENT -> addAttribute [232:20]
1928 | | |--ELIST -> ELIST [232:33]
1929 | | | |--EXPR -> EXPR [232:33]
1930 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [232:33]
1931 | | | |--COMMA -> , [232:58]
1932 | | | `--EXPR -> EXPR [232:60]
1933 | | | `--STRING_LITERAL -> "8" [232:60]
1934 | | `--RPAREN -> ) [232:63]
1935 | |--SEMI -> ; [232:64]
1936 | |--EXPR -> EXPR [233:32]
1937 | | `--METHOD_CALL -> ( [233:32]
1938 | | |--DOT -> . [233:19]
1939 | | | |--IDENT -> checkConfig [233:8]
1940 | | | `--IDENT -> addAttribute [233:20]
1941 | | |--ELIST -> ELIST [233:33]
1942 | | | |--EXPR -> EXPR [233:33]
1943 | | | | `--STRING_LITERAL -> "tabWidth" [233:33]
1944 | | | |--COMMA -> , [233:43]
1945 | | | `--EXPR -> EXPR [233:45]
1946 | | | `--STRING_LITERAL -> "4" [233:45]
1947 | | `--RPAREN -> ) [233:48]
1948 | |--SEMI -> ; [233:49]
1949 | |--EXPR -> EXPR [234:32]
1950 | | `--METHOD_CALL -> ( [234:32]
1951 | | |--DOT -> . [234:19]
1952 | | | |--IDENT -> checkConfig [234:8]
1953 | | | `--IDENT -> addAttribute [234:20]
1954 | | |--ELIST -> ELIST [234:33]
1955 | | | |--EXPR -> EXPR [234:33]
1956 | | | | `--STRING_LITERAL -> "throwsIndent" [234:33]
1957 | | | |--COMMA -> , [234:47]
1958 | | | `--EXPR -> EXPR [234:49]
1959 | | | `--STRING_LITERAL -> "8" [234:49]
1960 | | `--RPAREN -> ) [234:52]
1961 | |--SEMI -> ; [234:53]
1962 | |--VARIABLE_DEF -> VARIABLE_DEF [235:8]
1963 | | |--MODIFIERS -> MODIFIERS [235:8]
1964 | | | `--FINAL -> final [235:8]
1965 | | |--TYPE -> TYPE [235:20]
1966 | | | `--ARRAY_DECLARATOR -> [ [235:20]
1967 | | | |--IDENT -> String [235:14]
1968 | | | `--RBRACK -> ] [235:21]
1969 | | |--IDENT -> expected [235:23]
1970 | | `--ASSIGN -> = [235:32]
1971 | | `--ARRAY_INIT -> { [235:34]
1972 | | |--EXPR -> EXPR [236:22]
1973 | | | `--PLUS -> + [236:22]
1974 | | | |--STRING_LITERAL -> "20:30: " [236:12]
1975 | | | `--METHOD_CALL -> ( [236:39]
1976 | | | |--IDENT -> getCheckMessage [236:24]
1977 | | | |--ELIST -> ELIST [236:40]
1978 | | | | |--EXPR -> EXPR [236:40]
1979 | | | | | `--IDENT -> MSG_ERROR [236:40]
1980 | | | | |--COMMA -> , [236:49]
1981 | | | | |--EXPR -> EXPR [236:51]
1982 | | | | | `--STRING_LITERAL -> "int" [236:51]
1983 | | | | |--COMMA -> , [236:56]
1984 | | | | |--EXPR -> EXPR [236:58]
1985 | | | | | `--NUM_INT -> 29 [236:58]
1986 | | | | |--COMMA -> , [236:60]
1987 | | | | `--EXPR -> EXPR [236:62]
1988 | | | | `--NUM_INT -> 12 [236:62]
1989 | | | `--RPAREN -> ) [236:64]
1990 | | |--COMMA -> , [236:65]
1991 | | |--EXPR -> EXPR [237:22]
1992 | | | `--PLUS -> + [237:22]
1993 | | | |--STRING_LITERAL -> "21:30: " [237:12]
1994 | | | `--METHOD_CALL -> ( [237:39]
1995 | | | |--IDENT -> getCheckMessage [237:24]
1996 | | | |--ELIST -> ELIST [237:40]
1997 | | | | |--EXPR -> EXPR [237:40]
1998 | | | | | `--IDENT -> MSG_ERROR [237:40]
1999 | | | | |--COMMA -> , [237:49]
2000 | | | | |--EXPR -> EXPR [237:51]
2001 | | | | | `--STRING_LITERAL -> "int" [237:51]
2002 | | | | |--COMMA -> , [237:56]
2003 | | | | |--EXPR -> EXPR [237:58]
2004 | | | | | `--NUM_INT -> 29 [237:58]
2005 | | | | |--COMMA -> , [237:60]
2006 | | | | `--EXPR -> EXPR [237:62]
2007 | | | | `--NUM_INT -> 12 [237:62]
2008 | | | `--RPAREN -> ) [237:64]
2009 | | |--COMMA -> , [237:65]
2010 | | `--RCURLY -> } [238:8]
2011 | |--SEMI -> ; [238:9]
2012 | |--EXPR -> EXPR [239:19]
2013 | | `--METHOD_CALL -> ( [239:19]
2014 | | |--IDENT -> verifyWarns [239:8]
2015 | | |--ELIST -> ELIST [239:20]
2016 | | | |--EXPR -> EXPR [239:20]
2017 | | | | `--IDENT -> checkConfig [239:20]
2018 | | | |--COMMA -> , [239:31]
2019 | | | |--EXPR -> EXPR [239:40]
2020 | | | | `--METHOD_CALL -> ( [239:40]
2021 | | | | |--IDENT -> getPath [239:33]
2022 | | | | |--ELIST -> ELIST [239:41]
2023 | | | | | `--EXPR -> EXPR [239:41]
2024 | | | | | `--STRING_LITERAL -> "InputIndentationMethodCStyle.java" [239:41]
2025 | | | | `--RPAREN -> ) [239:76]
2026 | | | |--COMMA -> , [239:77]
2027 | | | `--EXPR -> EXPR [239:79]
2028 | | | `--IDENT -> expected [239:79]
2029 | | `--RPAREN -> ) [239:87]
2030 | |--SEMI -> ; [239:88]
2031 | `--RCURLY -> } [240:4]
2032 |--METHOD_DEF -> METHOD_DEF [242:4]
2033 | |--MODIFIERS -> MODIFIERS [242:4]
2034 | | |--ANNOTATION -> ANNOTATION [242:4]
2035 | | | |--AT -> @ [242:4]
2036 | | | `--IDENT -> Test [242:5]
2037 | | `--LITERAL_PUBLIC -> public [243:4]
2038 | |--TYPE -> TYPE [243:11]
2039 | | `--LITERAL_VOID -> void [243:11]
2040 | |--IDENT -> testZeroCaseLevel [243:16]
2041 | |--LPAREN -> ( [243:33]
2042 | |--PARAMETERS -> PARAMETERS [243:34]
2043 | |--RPAREN -> ) [243:34]
2044 | |--LITERAL_THROWS -> throws [243:36]
2045 | | `--IDENT -> Exception [243:43]
2046 | `--SLIST -> { [243:53]
2047 | |--VARIABLE_DEF -> VARIABLE_DEF [244:8]
2048 | | |--MODIFIERS -> MODIFIERS [244:8]
2049 | | | `--FINAL -> final [244:8]
2050 | | |--TYPE -> TYPE [244:14]
2051 | | | `--IDENT -> DefaultConfiguration [244:14]
2052 | | |--IDENT -> checkConfig [244:35]
2053 | | `--ASSIGN -> = [244:47]
2054 | | `--EXPR -> EXPR [244:67]
2055 | | `--METHOD_CALL -> ( [244:67]
2056 | | |--IDENT -> createModuleConfig [244:49]
2057 | | |--ELIST -> ELIST [244:84]
2058 | | | `--EXPR -> EXPR [244:84]
2059 | | | `--DOT -> . [244:84]
2060 | | | |--IDENT -> IndentationCheck [244:68]
2061 | | | `--LITERAL_CLASS -> class [244:85]
2062 | | `--RPAREN -> ) [244:90]
2063 | |--SEMI -> ; [244:91]
2064 | |--EXPR -> EXPR [245:32]
2065 | | `--METHOD_CALL -> ( [245:32]
2066 | | |--DOT -> . [245:19]
2067 | | | |--IDENT -> checkConfig [245:8]
2068 | | | `--IDENT -> addAttribute [245:20]
2069 | | |--ELIST -> ELIST [245:33]
2070 | | | |--EXPR -> EXPR [245:33]
2071 | | | | `--STRING_LITERAL -> "arrayInitIndent" [245:33]
2072 | | | |--COMMA -> , [245:50]
2073 | | | `--EXPR -> EXPR [245:52]
2074 | | | `--STRING_LITERAL -> "4" [245:52]
2075 | | `--RPAREN -> ) [245:55]
2076 | |--SEMI -> ; [245:56]
2077 | |--EXPR -> EXPR [246:32]
2078 | | `--METHOD_CALL -> ( [246:32]
2079 | | |--DOT -> . [246:19]
2080 | | | |--IDENT -> checkConfig [246:8]
2081 | | | `--IDENT -> addAttribute [246:20]
2082 | | |--ELIST -> ELIST [246:33]
2083 | | | |--EXPR -> EXPR [246:33]
2084 | | | | `--STRING_LITERAL -> "basicOffset" [246:33]
2085 | | | |--COMMA -> , [246:46]
2086 | | | `--EXPR -> EXPR [246:48]
2087 | | | `--STRING_LITERAL -> "4" [246:48]
2088 | | `--RPAREN -> ) [246:51]
2089 | |--SEMI -> ; [246:52]
2090 | |--EXPR -> EXPR [247:32]
2091 | | `--METHOD_CALL -> ( [247:32]
2092 | | |--DOT -> . [247:19]
2093 | | | |--IDENT -> checkConfig [247:8]
2094 | | | `--IDENT -> addAttribute [247:20]
2095 | | |--ELIST -> ELIST [247:33]
2096 | | | |--EXPR -> EXPR [247:33]
2097 | | | | `--STRING_LITERAL -> "braceAdjustment" [247:33]
2098 | | | |--COMMA -> , [247:50]
2099 | | | `--EXPR -> EXPR [247:52]
2100 | | | `--STRING_LITERAL -> "0" [247:52]
2101 | | `--RPAREN -> ) [247:55]
2102 | |--SEMI -> ; [247:56]
2103 | |--EXPR -> EXPR [248:32]
2104 | | `--METHOD_CALL -> ( [248:32]
2105 | | |--DOT -> . [248:19]
2106 | | | |--IDENT -> checkConfig [248:8]
2107 | | | `--IDENT -> addAttribute [248:20]
2108 | | |--ELIST -> ELIST [248:33]
2109 | | | |--EXPR -> EXPR [248:33]
2110 | | | | `--STRING_LITERAL -> "caseIndent" [248:33]
2111 | | | |--COMMA -> , [248:45]
2112 | | | `--EXPR -> EXPR [248:47]
2113 | | | `--STRING_LITERAL -> "0" [248:47]
2114 | | `--RPAREN -> ) [248:50]
2115 | |--SEMI -> ; [248:51]
2116 | |--EXPR -> EXPR [249:32]
2117 | | `--METHOD_CALL -> ( [249:32]
2118 | | |--DOT -> . [249:19]
2119 | | | |--IDENT -> checkConfig [249:8]
2120 | | | `--IDENT -> addAttribute [249:20]
2121 | | |--ELIST -> ELIST [249:33]
2122 | | | |--EXPR -> EXPR [249:33]
2123 | | | | `--STRING_LITERAL -> "forceStrictCondition" [249:33]
2124 | | | |--COMMA -> , [249:55]
2125 | | | `--EXPR -> EXPR [249:57]
2126 | | | `--STRING_LITERAL -> "false" [249:57]
2127 | | `--RPAREN -> ) [249:64]
2128 | |--SEMI -> ; [249:65]
2129 | |--EXPR -> EXPR [250:32]
2130 | | `--METHOD_CALL -> ( [250:32]
2131 | | |--DOT -> . [250:19]
2132 | | | |--IDENT -> checkConfig [250:8]
2133 | | | `--IDENT -> addAttribute [250:20]
2134 | | |--ELIST -> ELIST [250:33]
2135 | | | |--EXPR -> EXPR [250:33]
2136 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [250:33]
2137 | | | |--COMMA -> , [250:58]
2138 | | | `--EXPR -> EXPR [250:60]
2139 | | | `--STRING_LITERAL -> "4" [250:60]
2140 | | `--RPAREN -> ) [250:63]
2141 | |--SEMI -> ; [250:64]
2142 | |--EXPR -> EXPR [251:32]
2143 | | `--METHOD_CALL -> ( [251:32]
2144 | | |--DOT -> . [251:19]
2145 | | | |--IDENT -> checkConfig [251:8]
2146 | | | `--IDENT -> addAttribute [251:20]
2147 | | |--ELIST -> ELIST [251:33]
2148 | | | |--EXPR -> EXPR [251:33]
2149 | | | | `--STRING_LITERAL -> "tabWidth" [251:33]
2150 | | | |--COMMA -> , [251:43]
2151 | | | `--EXPR -> EXPR [251:45]
2152 | | | `--STRING_LITERAL -> "4" [251:45]
2153 | | `--RPAREN -> ) [251:48]
2154 | |--SEMI -> ; [251:49]
2155 | |--EXPR -> EXPR [252:32]
2156 | | `--METHOD_CALL -> ( [252:32]
2157 | | |--DOT -> . [252:19]
2158 | | | |--IDENT -> checkConfig [252:8]
2159 | | | `--IDENT -> addAttribute [252:20]
2160 | | |--ELIST -> ELIST [252:33]
2161 | | | |--EXPR -> EXPR [252:33]
2162 | | | | `--STRING_LITERAL -> "throwsIndent" [252:33]
2163 | | | |--COMMA -> , [252:47]
2164 | | | `--EXPR -> EXPR [252:49]
2165 | | | `--STRING_LITERAL -> "4" [252:49]
2166 | | `--RPAREN -> ) [252:52]
2167 | |--SEMI -> ; [252:53]
2168 | |--VARIABLE_DEF -> VARIABLE_DEF [253:8]
2169 | | |--MODIFIERS -> MODIFIERS [253:8]
2170 | | | `--FINAL -> final [253:8]
2171 | | |--TYPE -> TYPE [253:20]
2172 | | | `--ARRAY_DECLARATOR -> [ [253:20]
2173 | | | |--IDENT -> String [253:14]
2174 | | | `--RBRACK -> ] [253:21]
2175 | | |--IDENT -> expected [253:23]
2176 | | `--ASSIGN -> = [253:32]
2177 | | `--EXPR -> EXPR [253:44]
2178 | | `--DOT -> . [253:44]
2179 | | |--IDENT -> CommonUtil [253:34]
2180 | | `--IDENT -> EMPTY_STRING_ARRAY [253:45]
2181 | |--SEMI -> ; [253:63]
2182 | |--EXPR -> EXPR [254:19]
2183 | | `--METHOD_CALL -> ( [254:19]
2184 | | |--IDENT -> verifyWarns [254:8]
2185 | | |--ELIST -> ELIST [254:20]
2186 | | | |--EXPR -> EXPR [254:20]
2187 | | | | `--IDENT -> checkConfig [254:20]
2188 | | | |--COMMA -> , [254:31]
2189 | | | |--EXPR -> EXPR [254:40]
2190 | | | | `--METHOD_CALL -> ( [254:40]
2191 | | | | |--IDENT -> getPath [254:33]
2192 | | | | |--ELIST -> ELIST [254:41]
2193 | | | | | `--EXPR -> EXPR [254:41]
2194 | | | | | `--STRING_LITERAL -> "InputIndentationZeroCaseLevel.java" [254:41]
2195 | | | | `--RPAREN -> ) [254:77]
2196 | | | |--COMMA -> , [254:78]
2197 | | | `--EXPR -> EXPR [254:80]
2198 | | | `--IDENT -> expected [254:80]
2199 | | `--RPAREN -> ) [254:88]
2200 | |--SEMI -> ; [254:89]
2201 | `--RCURLY -> } [255:4]
2202 |--METHOD_DEF -> METHOD_DEF [257:4]
2203 | |--MODIFIERS -> MODIFIERS [257:4]
2204 | | |--ANNOTATION -> ANNOTATION [257:4]
2205 | | | |--AT -> @ [257:4]
2206 | | | `--IDENT -> Test [257:5]
2207 | | `--LITERAL_PUBLIC -> public [258:4]
2208 | |--TYPE -> TYPE [258:11]
2209 | | `--LITERAL_VOID -> void [258:11]
2210 | |--IDENT -> testAndroidStyle [258:16]
2211 | |--LPAREN -> ( [258:32]
2212 | |--PARAMETERS -> PARAMETERS [258:33]
2213 | |--RPAREN -> ) [258:33]
2214 | |--LITERAL_THROWS -> throws [258:35]
2215 | | `--IDENT -> Exception [258:42]
2216 | `--SLIST -> { [258:52]
2217 | |--VARIABLE_DEF -> VARIABLE_DEF [259:8]
2218 | | |--MODIFIERS -> MODIFIERS [259:8]
2219 | | | `--FINAL -> final [259:8]
2220 | | |--TYPE -> TYPE [259:14]
2221 | | | `--IDENT -> DefaultConfiguration [259:14]
2222 | | |--IDENT -> checkConfig [259:35]
2223 | | `--ASSIGN -> = [259:47]
2224 | | `--EXPR -> EXPR [259:67]
2225 | | `--METHOD_CALL -> ( [259:67]
2226 | | |--IDENT -> createModuleConfig [259:49]
2227 | | |--ELIST -> ELIST [259:84]
2228 | | | `--EXPR -> EXPR [259:84]
2229 | | | `--DOT -> . [259:84]
2230 | | | |--IDENT -> IndentationCheck [259:68]
2231 | | | `--LITERAL_CLASS -> class [259:85]
2232 | | `--RPAREN -> ) [259:90]
2233 | |--SEMI -> ; [259:91]
2234 | |--EXPR -> EXPR [260:32]
2235 | | `--METHOD_CALL -> ( [260:32]
2236 | | |--DOT -> . [260:19]
2237 | | | |--IDENT -> checkConfig [260:8]
2238 | | | `--IDENT -> addAttribute [260:20]
2239 | | |--ELIST -> ELIST [260:33]
2240 | | | |--EXPR -> EXPR [260:33]
2241 | | | | `--STRING_LITERAL -> "arrayInitIndent" [260:33]
2242 | | | |--COMMA -> , [260:50]
2243 | | | `--EXPR -> EXPR [260:52]
2244 | | | `--STRING_LITERAL -> "4" [260:52]
2245 | | `--RPAREN -> ) [260:55]
2246 | |--SEMI -> ; [260:56]
2247 | |--EXPR -> EXPR [261:32]
2248 | | `--METHOD_CALL -> ( [261:32]
2249 | | |--DOT -> . [261:19]
2250 | | | |--IDENT -> checkConfig [261:8]
2251 | | | `--IDENT -> addAttribute [261:20]
2252 | | |--ELIST -> ELIST [261:33]
2253 | | | |--EXPR -> EXPR [261:33]
2254 | | | | `--STRING_LITERAL -> "basicOffset" [261:33]
2255 | | | |--COMMA -> , [261:46]
2256 | | | `--EXPR -> EXPR [261:48]
2257 | | | `--STRING_LITERAL -> "4" [261:48]
2258 | | `--RPAREN -> ) [261:51]
2259 | |--SEMI -> ; [261:52]
2260 | |--EXPR -> EXPR [262:32]
2261 | | `--METHOD_CALL -> ( [262:32]
2262 | | |--DOT -> . [262:19]
2263 | | | |--IDENT -> checkConfig [262:8]
2264 | | | `--IDENT -> addAttribute [262:20]
2265 | | |--ELIST -> ELIST [262:33]
2266 | | | |--EXPR -> EXPR [262:33]
2267 | | | | `--STRING_LITERAL -> "braceAdjustment" [262:33]
2268 | | | |--COMMA -> , [262:50]
2269 | | | `--EXPR -> EXPR [262:52]
2270 | | | `--STRING_LITERAL -> "0" [262:52]
2271 | | `--RPAREN -> ) [262:55]
2272 | |--SEMI -> ; [262:56]
2273 | |--EXPR -> EXPR [263:32]
2274 | | `--METHOD_CALL -> ( [263:32]
2275 | | |--DOT -> . [263:19]
2276 | | | |--IDENT -> checkConfig [263:8]
2277 | | | `--IDENT -> addAttribute [263:20]
2278 | | |--ELIST -> ELIST [263:33]
2279 | | | |--EXPR -> EXPR [263:33]
2280 | | | | `--STRING_LITERAL -> "caseIndent" [263:33]
2281 | | | |--COMMA -> , [263:45]
2282 | | | `--EXPR -> EXPR [263:47]
2283 | | | `--STRING_LITERAL -> "4" [263:47]
2284 | | `--RPAREN -> ) [263:50]
2285 | |--SEMI -> ; [263:51]
2286 | |--EXPR -> EXPR [264:32]
2287 | | `--METHOD_CALL -> ( [264:32]
2288 | | |--DOT -> . [264:19]
2289 | | | |--IDENT -> checkConfig [264:8]
2290 | | | `--IDENT -> addAttribute [264:20]
2291 | | |--ELIST -> ELIST [264:33]
2292 | | | |--EXPR -> EXPR [264:33]
2293 | | | | `--STRING_LITERAL -> "forceStrictCondition" [264:33]
2294 | | | |--COMMA -> , [264:55]
2295 | | | `--EXPR -> EXPR [264:57]
2296 | | | `--STRING_LITERAL -> "false" [264:57]
2297 | | `--RPAREN -> ) [264:64]
2298 | |--SEMI -> ; [264:65]
2299 | |--EXPR -> EXPR [265:32]
2300 | | `--METHOD_CALL -> ( [265:32]
2301 | | |--DOT -> . [265:19]
2302 | | | |--IDENT -> checkConfig [265:8]
2303 | | | `--IDENT -> addAttribute [265:20]
2304 | | |--ELIST -> ELIST [265:33]
2305 | | | |--EXPR -> EXPR [265:33]
2306 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [265:33]
2307 | | | |--COMMA -> , [265:58]
2308 | | | `--EXPR -> EXPR [265:60]
2309 | | | `--STRING_LITERAL -> "8" [265:60]
2310 | | `--RPAREN -> ) [265:63]
2311 | |--SEMI -> ; [265:64]
2312 | |--EXPR -> EXPR [266:32]
2313 | | `--METHOD_CALL -> ( [266:32]
2314 | | |--DOT -> . [266:19]
2315 | | | |--IDENT -> checkConfig [266:8]
2316 | | | `--IDENT -> addAttribute [266:20]
2317 | | |--ELIST -> ELIST [266:33]
2318 | | | |--EXPR -> EXPR [266:33]
2319 | | | | `--STRING_LITERAL -> "tabWidth" [266:33]
2320 | | | |--COMMA -> , [266:43]
2321 | | | `--EXPR -> EXPR [266:45]
2322 | | | `--STRING_LITERAL -> "4" [266:45]
2323 | | `--RPAREN -> ) [266:48]
2324 | |--SEMI -> ; [266:49]
2325 | |--EXPR -> EXPR [267:32]
2326 | | `--METHOD_CALL -> ( [267:32]
2327 | | |--DOT -> . [267:19]
2328 | | | |--IDENT -> checkConfig [267:8]
2329 | | | `--IDENT -> addAttribute [267:20]
2330 | | |--ELIST -> ELIST [267:33]
2331 | | | |--EXPR -> EXPR [267:33]
2332 | | | | `--STRING_LITERAL -> "throwsIndent" [267:33]
2333 | | | |--COMMA -> , [267:47]
2334 | | | `--EXPR -> EXPR [267:49]
2335 | | | `--STRING_LITERAL -> "8" [267:49]
2336 | | `--RPAREN -> ) [267:52]
2337 | |--SEMI -> ; [267:53]
2338 | |--VARIABLE_DEF -> VARIABLE_DEF [268:8]
2339 | | |--MODIFIERS -> MODIFIERS [268:8]
2340 | | | `--FINAL -> final [268:8]
2341 | | |--TYPE -> TYPE [268:20]
2342 | | | `--ARRAY_DECLARATOR -> [ [268:20]
2343 | | | |--IDENT -> String [268:14]
2344 | | | `--RBRACK -> ] [268:21]
2345 | | |--IDENT -> expected [268:23]
2346 | | `--ASSIGN -> = [268:32]
2347 | | `--ARRAY_INIT -> { [268:34]
2348 | | |--EXPR -> EXPR [269:21]
2349 | | | `--PLUS -> + [269:21]
2350 | | | |--STRING_LITERAL -> "42:4: " [269:12]
2351 | | | `--METHOD_CALL -> ( [269:38]
2352 | | | |--IDENT -> getCheckMessage [269:23]
2353 | | | |--ELIST -> ELIST [269:39]
2354 | | | | |--EXPR -> EXPR [269:39]
2355 | | | | | `--IDENT -> MSG_ERROR [269:39]
2356 | | | | |--COMMA -> , [269:48]
2357 | | | | |--EXPR -> EXPR [269:50]
2358 | | | | | `--STRING_LITERAL -> "extends" [269:50]
2359 | | | | |--COMMA -> , [269:59]
2360 | | | | |--EXPR -> EXPR [269:61]
2361 | | | | | `--NUM_INT -> 3 [269:61]
2362 | | | | |--COMMA -> , [269:62]
2363 | | | | `--EXPR -> EXPR [269:64]
2364 | | | | `--NUM_INT -> 8 [269:64]
2365 | | | `--RPAREN -> ) [269:65]
2366 | | |--COMMA -> , [269:66]
2367 | | |--EXPR -> EXPR [270:21]
2368 | | | `--PLUS -> + [270:21]
2369 | | | |--STRING_LITERAL -> "44:4: " [270:12]
2370 | | | `--METHOD_CALL -> ( [270:38]
2371 | | | |--IDENT -> getCheckMessage [270:23]
2372 | | | |--ELIST -> ELIST [270:39]
2373 | | | | |--EXPR -> EXPR [270:39]
2374 | | | | | `--IDENT -> MSG_ERROR [270:39]
2375 | | | | |--COMMA -> , [270:48]
2376 | | | | |--EXPR -> EXPR [270:50]
2377 | | | | | `--STRING_LITERAL -> "member def type" [270:50]
2378 | | | | |--COMMA -> , [270:67]
2379 | | | | |--EXPR -> EXPR [270:69]
2380 | | | | | `--NUM_INT -> 3 [270:69]
2381 | | | | |--COMMA -> , [270:70]
2382 | | | | `--EXPR -> EXPR [270:72]
2383 | | | | `--NUM_INT -> 4 [270:72]
2384 | | | `--RPAREN -> ) [270:73]
2385 | | |--COMMA -> , [270:74]
2386 | | |--EXPR -> EXPR [271:21]
2387 | | | `--PLUS -> + [271:21]
2388 | | | |--STRING_LITERAL -> "47:9: " [271:12]
2389 | | | `--METHOD_CALL -> ( [271:38]
2390 | | | |--IDENT -> getCheckMessage [271:23]
2391 | | | |--ELIST -> ELIST [271:39]
2392 | | | | |--EXPR -> EXPR [271:39]
2393 | | | | | `--IDENT -> MSG_ERROR [271:39]
2394 | | | | |--COMMA -> , [271:48]
2395 | | | | |--EXPR -> EXPR [271:50]
2396 | | | | | `--STRING_LITERAL -> "foo" [271:50]
2397 | | | | |--COMMA -> , [271:55]
2398 | | | | |--EXPR -> EXPR [271:57]
2399 | | | | | `--NUM_INT -> 8 [271:57]
2400 | | | | |--COMMA -> , [271:58]
2401 | | | | `--EXPR -> EXPR [271:60]
2402 | | | | `--NUM_INT -> 12 [271:60]
2403 | | | `--RPAREN -> ) [271:62]
2404 | | |--COMMA -> , [271:63]
2405 | | |--EXPR -> EXPR [272:21]
2406 | | | `--PLUS -> + [272:21]
2407 | | | |--STRING_LITERAL -> "50:9: " [272:12]
2408 | | | `--METHOD_CALL -> ( [272:38]
2409 | | | |--IDENT -> getCheckMessage [272:23]
2410 | | | |--ELIST -> ELIST [272:39]
2411 | | | | |--EXPR -> EXPR [272:39]
2412 | | | | | `--IDENT -> MSG_ERROR [272:39]
2413 | | | | |--COMMA -> , [272:48]
2414 | | | | |--EXPR -> EXPR [272:50]
2415 | | | | | `--STRING_LITERAL -> "int" [272:50]
2416 | | | | |--COMMA -> , [272:55]
2417 | | | | |--EXPR -> EXPR [272:57]
2418 | | | | | `--NUM_INT -> 8 [272:57]
2419 | | | | |--COMMA -> , [272:58]
2420 | | | | `--EXPR -> EXPR [272:60]
2421 | | | | `--NUM_INT -> 12 [272:60]
2422 | | | `--RPAREN -> ) [272:62]
2423 | | |--COMMA -> , [272:63]
2424 | | |--EXPR -> EXPR [273:22]
2425 | | | `--PLUS -> + [273:22]
2426 | | | |--STRING_LITERAL -> "53:14: " [273:12]
2427 | | | `--METHOD_CALL -> ( [273:39]
2428 | | | |--IDENT -> getCheckMessage [273:24]
2429 | | | |--ELIST -> ELIST [273:40]
2430 | | | | |--EXPR -> EXPR [273:40]
2431 | | | | | `--IDENT -> MSG_ERROR [273:40]
2432 | | | | |--COMMA -> , [273:49]
2433 | | | | |--EXPR -> EXPR [273:51]
2434 | | | | | `--STRING_LITERAL -> "true" [273:51]
2435 | | | | |--COMMA -> , [273:57]
2436 | | | | |--EXPR -> EXPR [273:59]
2437 | | | | | `--NUM_INT -> 13 [273:59]
2438 | | | | |--COMMA -> , [273:61]
2439 | | | | `--EXPR -> EXPR [273:63]
2440 | | | | `--NUM_INT -> 16 [273:63]
2441 | | | `--RPAREN -> ) [273:65]
2442 | | |--COMMA -> , [273:66]
2443 | | |--EXPR -> EXPR [274:22]
2444 | | | `--PLUS -> + [274:22]
2445 | | | |--STRING_LITERAL -> "56:17: " [274:12]
2446 | | | `--METHOD_CALL -> ( [274:39]
2447 | | | |--IDENT -> getCheckMessage [274:24]
2448 | | | |--ELIST -> ELIST [274:40]
2449 | | | | |--EXPR -> EXPR [274:40]
2450 | | | | | `--IDENT -> MSG_ERROR [274:40]
2451 | | | | |--COMMA -> , [274:49]
2452 | | | | |--EXPR -> EXPR [274:51]
2453 | | | | | `--STRING_LITERAL -> "+" [274:51]
2454 | | | | |--COMMA -> , [274:54]
2455 | | | | |--EXPR -> EXPR [274:56]
2456 | | | | | `--NUM_INT -> 16 [274:56]
2457 | | | | |--COMMA -> , [274:58]
2458 | | | | `--EXPR -> EXPR [274:60]
2459 | | | | `--NUM_INT -> 20 [274:60]
2460 | | | `--RPAREN -> ) [274:62]
2461 | | |--COMMA -> , [274:63]
2462 | | |--EXPR -> EXPR [275:21]
2463 | | | `--PLUS -> + [275:21]
2464 | | | |--STRING_LITERAL -> "57:9: " [275:12]
2465 | | | `--METHOD_CALL -> ( [275:38]
2466 | | | |--IDENT -> getCheckMessage [275:23]
2467 | | | |--ELIST -> ELIST [275:39]
2468 | | | | |--EXPR -> EXPR [275:39]
2469 | | | | | `--IDENT -> MSG_ERROR [275:39]
2470 | | | | |--COMMA -> , [275:48]
2471 | | | | |--EXPR -> EXPR [275:50]
2472 | | | | | `--STRING_LITERAL -> "if" [275:50]
2473 | | | | |--COMMA -> , [275:54]
2474 | | | | |--EXPR -> EXPR [275:56]
2475 | | | | | `--NUM_INT -> 8 [275:56]
2476 | | | | |--COMMA -> , [275:57]
2477 | | | | `--EXPR -> EXPR [275:59]
2478 | | | | `--NUM_INT -> 12 [275:59]
2479 | | | `--RPAREN -> ) [275:61]
2480 | | |--COMMA -> , [275:62]
2481 | | |--EXPR -> EXPR [276:22]
2482 | | | `--PLUS -> + [276:22]
2483 | | | |--STRING_LITERAL -> "60:12: " [276:12]
2484 | | | `--METHOD_CALL -> ( [276:39]
2485 | | | |--IDENT -> getCheckMessage [276:24]
2486 | | | |--ELIST -> ELIST [276:40]
2487 | | | | |--EXPR -> EXPR [276:40]
2488 | | | | | `--IDENT -> MSG_ERROR [276:40]
2489 | | | | |--COMMA -> , [276:49]
2490 | | | | |--EXPR -> EXPR [276:51]
2491 | | | | | `--STRING_LITERAL -> "if rcurly" [276:51]
2492 | | | | |--COMMA -> , [276:62]
2493 | | | | |--EXPR -> EXPR [276:64]
2494 | | | | | `--NUM_INT -> 11 [276:64]
2495 | | | | |--COMMA -> , [276:66]
2496 | | | | `--EXPR -> EXPR [276:68]
2497 | | | | `--NUM_INT -> 12 [276:68]
2498 | | | `--RPAREN -> ) [276:70]
2499 | | |--COMMA -> , [276:71]
2500 | | |--EXPR -> EXPR [277:21]
2501 | | | `--PLUS -> + [277:21]
2502 | | | |--STRING_LITERAL -> "62:8: " [277:12]
2503 | | | `--METHOD_CALL -> ( [277:38]
2504 | | | |--IDENT -> getCheckMessage [277:23]
2505 | | | |--ELIST -> ELIST [277:39]
2506 | | | | |--EXPR -> EXPR [277:39]
2507 | | | | | `--IDENT -> MSG_CHILD_ERROR [277:39]
2508 | | | | |--COMMA -> , [277:54]
2509 | | | | |--EXPR -> EXPR [277:56]
2510 | | | | | `--STRING_LITERAL -> "method def" [277:56]
2511 | | | | |--COMMA -> , [277:68]
2512 | | | | |--EXPR -> EXPR [277:70]
2513 | | | | | `--NUM_INT -> 7 [277:70]
2514 | | | | |--COMMA -> , [277:71]
2515 | | | | `--EXPR -> EXPR [277:73]
2516 | | | | `--NUM_INT -> 8 [277:73]
2517 | | | `--RPAREN -> ) [277:74]
2518 | | |--COMMA -> , [277:75]
2519 | | `--RCURLY -> } [278:8]
2520 | |--SEMI -> ; [278:9]
2521 | |--EXPR -> EXPR [279:19]
2522 | | `--METHOD_CALL -> ( [279:19]
2523 | | |--IDENT -> verifyWarns [279:8]
2524 | | |--ELIST -> ELIST [279:20]
2525 | | | |--EXPR -> EXPR [279:20]
2526 | | | | `--IDENT -> checkConfig [279:20]
2527 | | | |--COMMA -> , [279:31]
2528 | | | |--EXPR -> EXPR [279:40]
2529 | | | | `--METHOD_CALL -> ( [279:40]
2530 | | | | |--IDENT -> getPath [279:33]
2531 | | | | |--ELIST -> ELIST [279:41]
2532 | | | | | `--EXPR -> EXPR [279:41]
2533 | | | | | `--STRING_LITERAL -> "InputIndentationAndroidStyle.java" [279:41]
2534 | | | | `--RPAREN -> ) [279:76]
2535 | | | |--COMMA -> , [279:77]
2536 | | | `--EXPR -> EXPR [279:79]
2537 | | | `--IDENT -> expected [279:79]
2538 | | `--RPAREN -> ) [279:87]
2539 | |--SEMI -> ; [279:88]
2540 | `--RCURLY -> } [280:4]
2541 |--METHOD_DEF -> METHOD_DEF [282:4]
2542 | |--MODIFIERS -> MODIFIERS [282:4]
2543 | | |--ANNOTATION -> ANNOTATION [282:4]
2544 | | | |--AT -> @ [282:4]
2545 | | | `--IDENT -> Test [282:5]
2546 | | `--LITERAL_PUBLIC -> public [283:4]
2547 | |--TYPE -> TYPE [283:11]
2548 | | `--LITERAL_VOID -> void [283:11]
2549 | |--IDENT -> testMethodCallLineWrap [283:16]
2550 | |--LPAREN -> ( [283:38]
2551 | |--PARAMETERS -> PARAMETERS [283:39]
2552 | |--RPAREN -> ) [283:39]
2553 | |--LITERAL_THROWS -> throws [283:41]
2554 | | `--IDENT -> Exception [283:48]
2555 | `--SLIST -> { [283:58]
2556 | |--VARIABLE_DEF -> VARIABLE_DEF [284:8]
2557 | | |--MODIFIERS -> MODIFIERS [284:8]
2558 | | | `--FINAL -> final [284:8]
2559 | | |--TYPE -> TYPE [284:14]
2560 | | | `--IDENT -> DefaultConfiguration [284:14]
2561 | | |--IDENT -> checkConfig [284:35]
2562 | | `--ASSIGN -> = [284:47]
2563 | | `--EXPR -> EXPR [284:67]
2564 | | `--METHOD_CALL -> ( [284:67]
2565 | | |--IDENT -> createModuleConfig [284:49]
2566 | | |--ELIST -> ELIST [284:84]
2567 | | | `--EXPR -> EXPR [284:84]
2568 | | | `--DOT -> . [284:84]
2569 | | | |--IDENT -> IndentationCheck [284:68]
2570 | | | `--LITERAL_CLASS -> class [284:85]
2571 | | `--RPAREN -> ) [284:90]
2572 | |--SEMI -> ; [284:91]
2573 | |--EXPR -> EXPR [286:32]
2574 | | `--METHOD_CALL -> ( [286:32]
2575 | | |--DOT -> . [286:19]
2576 | | | |--IDENT -> checkConfig [286:8]
2577 | | | `--IDENT -> addAttribute [286:20]
2578 | | |--ELIST -> ELIST [286:33]
2579 | | | |--EXPR -> EXPR [286:33]
2580 | | | | `--STRING_LITERAL -> "arrayInitIndent" [286:33]
2581 | | | |--COMMA -> , [286:50]
2582 | | | `--EXPR -> EXPR [286:52]
2583 | | | `--STRING_LITERAL -> "4" [286:52]
2584 | | `--RPAREN -> ) [286:55]
2585 | |--SEMI -> ; [286:56]
2586 | |--EXPR -> EXPR [287:32]
2587 | | `--METHOD_CALL -> ( [287:32]
2588 | | |--DOT -> . [287:19]
2589 | | | |--IDENT -> checkConfig [287:8]
2590 | | | `--IDENT -> addAttribute [287:20]
2591 | | |--ELIST -> ELIST [287:33]
2592 | | | |--EXPR -> EXPR [287:33]
2593 | | | | `--STRING_LITERAL -> "basicOffset" [287:33]
2594 | | | |--COMMA -> , [287:46]
2595 | | | `--EXPR -> EXPR [287:48]
2596 | | | `--STRING_LITERAL -> "4" [287:48]
2597 | | `--RPAREN -> ) [287:51]
2598 | |--SEMI -> ; [287:52]
2599 | |--EXPR -> EXPR [288:32]
2600 | | `--METHOD_CALL -> ( [288:32]
2601 | | |--DOT -> . [288:19]
2602 | | | |--IDENT -> checkConfig [288:8]
2603 | | | `--IDENT -> addAttribute [288:20]
2604 | | |--ELIST -> ELIST [288:33]
2605 | | | |--EXPR -> EXPR [288:33]
2606 | | | | `--STRING_LITERAL -> "braceAdjustment" [288:33]
2607 | | | |--COMMA -> , [288:50]
2608 | | | `--EXPR -> EXPR [288:52]
2609 | | | `--STRING_LITERAL -> "0" [288:52]
2610 | | `--RPAREN -> ) [288:55]
2611 | |--SEMI -> ; [288:56]
2612 | |--EXPR -> EXPR [289:32]
2613 | | `--METHOD_CALL -> ( [289:32]
2614 | | |--DOT -> . [289:19]
2615 | | | |--IDENT -> checkConfig [289:8]
2616 | | | `--IDENT -> addAttribute [289:20]
2617 | | |--ELIST -> ELIST [289:33]
2618 | | | |--EXPR -> EXPR [289:33]
2619 | | | | `--STRING_LITERAL -> "caseIndent" [289:33]
2620 | | | |--COMMA -> , [289:45]
2621 | | | `--EXPR -> EXPR [289:47]
2622 | | | `--STRING_LITERAL -> "4" [289:47]
2623 | | `--RPAREN -> ) [289:50]
2624 | |--SEMI -> ; [289:51]
2625 | |--EXPR -> EXPR [290:32]
2626 | | `--METHOD_CALL -> ( [290:32]
2627 | | |--DOT -> . [290:19]
2628 | | | |--IDENT -> checkConfig [290:8]
2629 | | | `--IDENT -> addAttribute [290:20]
2630 | | |--ELIST -> ELIST [290:33]
2631 | | | |--EXPR -> EXPR [290:33]
2632 | | | | `--STRING_LITERAL -> "forceStrictCondition" [290:33]
2633 | | | |--COMMA -> , [290:55]
2634 | | | `--EXPR -> EXPR [290:57]
2635 | | | `--STRING_LITERAL -> "false" [290:57]
2636 | | `--RPAREN -> ) [290:64]
2637 | |--SEMI -> ; [290:65]
2638 | |--EXPR -> EXPR [291:32]
2639 | | `--METHOD_CALL -> ( [291:32]
2640 | | |--DOT -> . [291:19]
2641 | | | |--IDENT -> checkConfig [291:8]
2642 | | | `--IDENT -> addAttribute [291:20]
2643 | | |--ELIST -> ELIST [291:33]
2644 | | | |--EXPR -> EXPR [291:33]
2645 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [291:33]
2646 | | | |--COMMA -> , [291:58]
2647 | | | `--EXPR -> EXPR [291:60]
2648 | | | `--STRING_LITERAL -> "4" [291:60]
2649 | | `--RPAREN -> ) [291:63]
2650 | |--SEMI -> ; [291:64]
2651 | |--EXPR -> EXPR [292:32]
2652 | | `--METHOD_CALL -> ( [292:32]
2653 | | |--DOT -> . [292:19]
2654 | | | |--IDENT -> checkConfig [292:8]
2655 | | | `--IDENT -> addAttribute [292:20]
2656 | | |--ELIST -> ELIST [292:33]
2657 | | | |--EXPR -> EXPR [292:33]
2658 | | | | `--STRING_LITERAL -> "tabWidth" [292:33]
2659 | | | |--COMMA -> , [292:43]
2660 | | | `--EXPR -> EXPR [292:45]
2661 | | | `--STRING_LITERAL -> "4" [292:45]
2662 | | `--RPAREN -> ) [292:48]
2663 | |--SEMI -> ; [292:49]
2664 | |--EXPR -> EXPR [293:32]
2665 | | `--METHOD_CALL -> ( [293:32]
2666 | | |--DOT -> . [293:19]
2667 | | | |--IDENT -> checkConfig [293:8]
2668 | | | `--IDENT -> addAttribute [293:20]
2669 | | |--ELIST -> ELIST [293:33]
2670 | | | |--EXPR -> EXPR [293:33]
2671 | | | | `--STRING_LITERAL -> "throwsIndent" [293:33]
2672 | | | |--COMMA -> , [293:47]
2673 | | | `--EXPR -> EXPR [293:49]
2674 | | | `--STRING_LITERAL -> "4" [293:49]
2675 | | `--RPAREN -> ) [293:52]
2676 | |--SEMI -> ; [293:53]
2677 | |--VARIABLE_DEF -> VARIABLE_DEF [294:8]
2678 | | |--MODIFIERS -> MODIFIERS [294:8]
2679 | | | `--FINAL -> final [294:8]
2680 | | |--TYPE -> TYPE [294:20]
2681 | | | `--ARRAY_DECLARATOR -> [ [294:20]
2682 | | | |--IDENT -> String [294:14]
2683 | | | `--RBRACK -> ] [294:21]
2684 | | |--IDENT -> expected [294:23]
2685 | | `--ASSIGN -> = [294:32]
2686 | | `--ARRAY_INIT -> { [294:34]
2687 | | |--EXPR -> EXPR [295:22]
2688 | | | `--PLUS -> + [295:22]
2689 | | | |--STRING_LITERAL -> "53:19: " [295:12]
2690 | | | `--METHOD_CALL -> ( [295:39]
2691 | | | |--IDENT -> getCheckMessage [295:24]
2692 | | | |--ELIST -> ELIST [295:40]
2693 | | | | |--EXPR -> EXPR [295:40]
2694 | | | | | `--IDENT -> MSG_CHILD_ERROR [295:40]
2695 | | | | |--COMMA -> , [295:55]
2696 | | | | |--EXPR -> EXPR [295:57]
2697 | | | | | `--STRING_LITERAL -> "method call" [295:57]
2698 | | | | |--COMMA -> , [295:70]
2699 | | | | |--EXPR -> EXPR [295:72]
2700 | | | | | `--NUM_INT -> 18 [295:72]
2701 | | | | |--COMMA -> , [295:74]
2702 | | | | `--EXPR -> EXPR [295:76]
2703 | | | | `--NUM_INT -> 20 [295:76]
2704 | | | `--RPAREN -> ) [295:78]
2705 | | |--COMMA -> , [295:79]
2706 | | |--EXPR -> EXPR [296:22]
2707 | | | `--PLUS -> + [296:22]
2708 | | | |--STRING_LITERAL -> "54:15: " [296:12]
2709 | | | `--METHOD_CALL -> ( [296:39]
2710 | | | |--IDENT -> getCheckMessage [296:24]
2711 | | | |--ELIST -> ELIST [296:40]
2712 | | | | |--EXPR -> EXPR [296:40]
2713 | | | | | `--IDENT -> MSG_ERROR [296:40]
2714 | | | | |--COMMA -> , [296:49]
2715 | | | | |--EXPR -> EXPR [296:51]
2716 | | | | | `--STRING_LITERAL -> "method call rparen" [296:51]
2717 | | | | |--COMMA -> , [296:71]
2718 | | | | |--EXPR -> EXPR [296:73]
2719 | | | | | `--NUM_INT -> 14 [296:73]
2720 | | | | |--COMMA -> , [296:75]
2721 | | | | `--EXPR -> EXPR [296:77]
2722 | | | | `--NUM_INT -> 16 [296:77]
2723 | | | `--RPAREN -> ) [296:79]
2724 | | |--COMMA -> , [296:80]
2725 | | |--EXPR -> EXPR [297:22]
2726 | | | `--PLUS -> + [297:22]
2727 | | | |--STRING_LITERAL -> "75:13: " [297:12]
2728 | | | `--METHOD_CALL -> ( [297:39]
2729 | | | |--IDENT -> getCheckMessage [297:24]
2730 | | | |--ELIST -> ELIST [297:40]
2731 | | | | |--EXPR -> EXPR [297:40]
2732 | | | | | `--IDENT -> MSG_ERROR [297:40]
2733 | | | | |--COMMA -> , [297:49]
2734 | | | | |--EXPR -> EXPR [297:51]
2735 | | | | | `--STRING_LITERAL -> "lambda arguments" [297:51]
2736 | | | | |--COMMA -> , [297:69]
2737 | | | | |--EXPR -> EXPR [297:71]
2738 | | | | | `--NUM_INT -> 12 [297:71]
2739 | | | | |--COMMA -> , [297:73]
2740 | | | | `--EXPR -> EXPR [297:75]
2741 | | | | `--NUM_INT -> 16 [297:75]
2742 | | | `--RPAREN -> ) [297:77]
2743 | | |--COMMA -> , [297:78]
2744 | | `--RCURLY -> } [298:8]
2745 | |--SEMI -> ; [298:9]
2746 | |--EXPR -> EXPR [299:19]
2747 | | `--METHOD_CALL -> ( [299:19]
2748 | | |--IDENT -> verifyWarns [299:8]
2749 | | |--ELIST -> ELIST [299:20]
2750 | | | |--EXPR -> EXPR [299:20]
2751 | | | | `--IDENT -> checkConfig [299:20]
2752 | | | |--COMMA -> , [299:31]
2753 | | | |--EXPR -> EXPR [299:40]
2754 | | | | `--METHOD_CALL -> ( [299:40]
2755 | | | | |--IDENT -> getPath [299:33]
2756 | | | | |--ELIST -> ELIST [299:41]
2757 | | | | | `--EXPR -> EXPR [299:41]
2758 | | | | | `--STRING_LITERAL -> "InputIndentationMethodCallLineWrap.java" [299:41]
2759 | | | | `--RPAREN -> ) [299:82]
2760 | | | |--COMMA -> , [299:83]
2761 | | | `--EXPR -> EXPR [299:85]
2762 | | | `--IDENT -> expected [299:85]
2763 | | `--RPAREN -> ) [299:93]
2764 | |--SEMI -> ; [299:94]
2765 | `--RCURLY -> } [300:4]
2766 |--METHOD_DEF -> METHOD_DEF [302:4]
2767 | |--MODIFIERS -> MODIFIERS [302:4]
2768 | | |--ANNOTATION -> ANNOTATION [302:4]
2769 | | | |--AT -> @ [302:4]
2770 | | | `--IDENT -> Test [302:5]
2771 | | `--LITERAL_PUBLIC -> public [303:4]
2772 | |--TYPE -> TYPE [303:11]
2773 | | `--LITERAL_VOID -> void [303:11]
2774 | |--IDENT -> testDifficultAnnotations [303:16]
2775 | |--LPAREN -> ( [303:40]
2776 | |--PARAMETERS -> PARAMETERS [303:41]
2777 | |--RPAREN -> ) [303:41]
2778 | |--LITERAL_THROWS -> throws [303:43]
2779 | | `--IDENT -> Exception [303:50]
2780 | `--SLIST -> { [303:60]
2781 | |--VARIABLE_DEF -> VARIABLE_DEF [304:8]
2782 | | |--MODIFIERS -> MODIFIERS [304:8]
2783 | | | `--FINAL -> final [304:8]
2784 | | |--TYPE -> TYPE [304:14]
2785 | | | `--IDENT -> DefaultConfiguration [304:14]
2786 | | |--IDENT -> checkConfig [304:35]
2787 | | `--ASSIGN -> = [304:47]
2788 | | `--EXPR -> EXPR [304:67]
2789 | | `--METHOD_CALL -> ( [304:67]
2790 | | |--IDENT -> createModuleConfig [304:49]
2791 | | |--ELIST -> ELIST [304:84]
2792 | | | `--EXPR -> EXPR [304:84]
2793 | | | `--DOT -> . [304:84]
2794 | | | |--IDENT -> IndentationCheck [304:68]
2795 | | | `--LITERAL_CLASS -> class [304:85]
2796 | | `--RPAREN -> ) [304:90]
2797 | |--SEMI -> ; [304:91]
2798 | |--EXPR -> EXPR [306:32]
2799 | | `--METHOD_CALL -> ( [306:32]
2800 | | |--DOT -> . [306:19]
2801 | | | |--IDENT -> checkConfig [306:8]
2802 | | | `--IDENT -> addAttribute [306:20]
2803 | | |--ELIST -> ELIST [306:33]
2804 | | | |--EXPR -> EXPR [306:33]
2805 | | | | `--STRING_LITERAL -> "arrayInitIndent" [306:33]
2806 | | | |--COMMA -> , [306:50]
2807 | | | `--EXPR -> EXPR [306:52]
2808 | | | `--STRING_LITERAL -> "4" [306:52]
2809 | | `--RPAREN -> ) [306:55]
2810 | |--SEMI -> ; [306:56]
2811 | |--EXPR -> EXPR [307:32]
2812 | | `--METHOD_CALL -> ( [307:32]
2813 | | |--DOT -> . [307:19]
2814 | | | |--IDENT -> checkConfig [307:8]
2815 | | | `--IDENT -> addAttribute [307:20]
2816 | | |--ELIST -> ELIST [307:33]
2817 | | | |--EXPR -> EXPR [307:33]
2818 | | | | `--STRING_LITERAL -> "basicOffset" [307:33]
2819 | | | |--COMMA -> , [307:46]
2820 | | | `--EXPR -> EXPR [307:48]
2821 | | | `--STRING_LITERAL -> "4" [307:48]
2822 | | `--RPAREN -> ) [307:51]
2823 | |--SEMI -> ; [307:52]
2824 | |--EXPR -> EXPR [308:32]
2825 | | `--METHOD_CALL -> ( [308:32]
2826 | | |--DOT -> . [308:19]
2827 | | | |--IDENT -> checkConfig [308:8]
2828 | | | `--IDENT -> addAttribute [308:20]
2829 | | |--ELIST -> ELIST [308:33]
2830 | | | |--EXPR -> EXPR [308:33]
2831 | | | | `--STRING_LITERAL -> "braceAdjustment" [308:33]
2832 | | | |--COMMA -> , [308:50]
2833 | | | `--EXPR -> EXPR [308:52]
2834 | | | `--STRING_LITERAL -> "0" [308:52]
2835 | | `--RPAREN -> ) [308:55]
2836 | |--SEMI -> ; [308:56]
2837 | |--EXPR -> EXPR [309:32]
2838 | | `--METHOD_CALL -> ( [309:32]
2839 | | |--DOT -> . [309:19]
2840 | | | |--IDENT -> checkConfig [309:8]
2841 | | | `--IDENT -> addAttribute [309:20]
2842 | | |--ELIST -> ELIST [309:33]
2843 | | | |--EXPR -> EXPR [309:33]
2844 | | | | `--STRING_LITERAL -> "caseIndent" [309:33]
2845 | | | |--COMMA -> , [309:45]
2846 | | | `--EXPR -> EXPR [309:47]
2847 | | | `--STRING_LITERAL -> "4" [309:47]
2848 | | `--RPAREN -> ) [309:50]
2849 | |--SEMI -> ; [309:51]
2850 | |--EXPR -> EXPR [310:32]
2851 | | `--METHOD_CALL -> ( [310:32]
2852 | | |--DOT -> . [310:19]
2853 | | | |--IDENT -> checkConfig [310:8]
2854 | | | `--IDENT -> addAttribute [310:20]
2855 | | |--ELIST -> ELIST [310:33]
2856 | | | |--EXPR -> EXPR [310:33]
2857 | | | | `--STRING_LITERAL -> "forceStrictCondition" [310:33]
2858 | | | |--COMMA -> , [310:55]
2859 | | | `--EXPR -> EXPR [310:57]
2860 | | | `--STRING_LITERAL -> "false" [310:57]
2861 | | `--RPAREN -> ) [310:64]
2862 | |--SEMI -> ; [310:65]
2863 | |--EXPR -> EXPR [311:32]
2864 | | `--METHOD_CALL -> ( [311:32]
2865 | | |--DOT -> . [311:19]
2866 | | | |--IDENT -> checkConfig [311:8]
2867 | | | `--IDENT -> addAttribute [311:20]
2868 | | |--ELIST -> ELIST [311:33]
2869 | | | |--EXPR -> EXPR [311:33]
2870 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [311:33]
2871 | | | |--COMMA -> , [311:58]
2872 | | | `--EXPR -> EXPR [311:60]
2873 | | | `--STRING_LITERAL -> "4" [311:60]
2874 | | `--RPAREN -> ) [311:63]
2875 | |--SEMI -> ; [311:64]
2876 | |--EXPR -> EXPR [312:32]
2877 | | `--METHOD_CALL -> ( [312:32]
2878 | | |--DOT -> . [312:19]
2879 | | | |--IDENT -> checkConfig [312:8]
2880 | | | `--IDENT -> addAttribute [312:20]
2881 | | |--ELIST -> ELIST [312:33]
2882 | | | |--EXPR -> EXPR [312:33]
2883 | | | | `--STRING_LITERAL -> "tabWidth" [312:33]
2884 | | | |--COMMA -> , [312:43]
2885 | | | `--EXPR -> EXPR [312:45]
2886 | | | `--STRING_LITERAL -> "4" [312:45]
2887 | | `--RPAREN -> ) [312:48]
2888 | |--SEMI -> ; [312:49]
2889 | |--EXPR -> EXPR [313:32]
2890 | | `--METHOD_CALL -> ( [313:32]
2891 | | |--DOT -> . [313:19]
2892 | | | |--IDENT -> checkConfig [313:8]
2893 | | | `--IDENT -> addAttribute [313:20]
2894 | | |--ELIST -> ELIST [313:33]
2895 | | | |--EXPR -> EXPR [313:33]
2896 | | | | `--STRING_LITERAL -> "throwsIndent" [313:33]
2897 | | | |--COMMA -> , [313:47]
2898 | | | `--EXPR -> EXPR [313:49]
2899 | | | `--STRING_LITERAL -> "4" [313:49]
2900 | | `--RPAREN -> ) [313:52]
2901 | |--SEMI -> ; [313:53]
2902 | |--VARIABLE_DEF -> VARIABLE_DEF [314:8]
2903 | | |--MODIFIERS -> MODIFIERS [314:8]
2904 | | | `--FINAL -> final [314:8]
2905 | | |--TYPE -> TYPE [314:20]
2906 | | | `--ARRAY_DECLARATOR -> [ [314:20]
2907 | | | |--IDENT -> String [314:14]
2908 | | | `--RBRACK -> ] [314:21]
2909 | | |--IDENT -> expected [314:23]
2910 | | `--ASSIGN -> = [314:32]
2911 | | `--ARRAY_INIT -> { [314:34]
2912 | | |--EXPR -> EXPR [315:21]
2913 | | | `--PLUS -> + [315:21]
2914 | | | |--STRING_LITERAL -> "40:1: " [315:12]
2915 | | | `--METHOD_CALL -> ( [315:38]
2916 | | | |--IDENT -> getCheckMessage [315:23]
2917 | | | |--ELIST -> ELIST [315:39]
2918 | | | | |--EXPR -> EXPR [315:39]
2919 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [315:39]
2920 | | | | |--COMMA -> , [315:60]
2921 | | | | |--EXPR -> EXPR [316:20]
2922 | | | | | `--STRING_LITERAL -> "annotation array initialization" [316:20]
2923 | | | | |--COMMA -> , [316:53]
2924 | | | | |--EXPR -> EXPR [316:55]
2925 | | | | | `--NUM_INT -> 0 [316:55]
2926 | | | | |--COMMA -> , [316:56]
2927 | | | | `--EXPR -> EXPR [316:58]
2928 | | | | `--STRING_LITERAL -> "4, 23, 25" [316:58]
2929 | | | `--RPAREN -> ) [316:69]
2930 | | |--COMMA -> , [316:70]
2931 | | |--EXPR -> EXPR [317:21]
2932 | | | `--PLUS -> + [317:21]
2933 | | | |--STRING_LITERAL -> "41:1: " [317:12]
2934 | | | `--METHOD_CALL -> ( [317:38]
2935 | | | |--IDENT -> getCheckMessage [317:23]
2936 | | | |--ELIST -> ELIST [317:39]
2937 | | | | |--EXPR -> EXPR [317:39]
2938 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [317:39]
2939 | | | | |--COMMA -> , [317:60]
2940 | | | | |--EXPR -> EXPR [318:20]
2941 | | | | | `--STRING_LITERAL -> "annotation array initialization" [318:20]
2942 | | | | |--COMMA -> , [318:53]
2943 | | | | |--EXPR -> EXPR [318:55]
2944 | | | | | `--NUM_INT -> 0 [318:55]
2945 | | | | |--COMMA -> , [318:56]
2946 | | | | `--EXPR -> EXPR [318:58]
2947 | | | | `--STRING_LITERAL -> "4, 23, 25" [318:58]
2948 | | | `--RPAREN -> ) [318:69]
2949 | | |--COMMA -> , [318:70]
2950 | | |--EXPR -> EXPR [319:21]
2951 | | | `--PLUS -> + [319:21]
2952 | | | |--STRING_LITERAL -> "50:7: " [319:12]
2953 | | | `--METHOD_CALL -> ( [319:38]
2954 | | | |--IDENT -> getCheckMessage [319:23]
2955 | | | |--ELIST -> ELIST [319:39]
2956 | | | | |--EXPR -> EXPR [319:39]
2957 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [319:39]
2958 | | | | |--COMMA -> , [319:60]
2959 | | | | |--EXPR -> EXPR [320:20]
2960 | | | | | `--STRING_LITERAL -> "annotation array initialization" [320:20]
2961 | | | | |--COMMA -> , [320:53]
2962 | | | | |--EXPR -> EXPR [320:55]
2963 | | | | | `--NUM_INT -> 6 [320:55]
2964 | | | | |--COMMA -> , [320:56]
2965 | | | | `--EXPR -> EXPR [320:58]
2966 | | | | `--STRING_LITERAL -> "8, 27, 29" [320:58]
2967 | | | `--RPAREN -> ) [320:69]
2968 | | |--COMMA -> , [320:70]
2969 | | `--RCURLY -> } [321:8]
2970 | |--SEMI -> ; [321:9]
2971 | |--EXPR -> EXPR [322:19]
2972 | | `--METHOD_CALL -> ( [322:19]
2973 | | |--IDENT -> verifyWarns [322:8]
2974 | | |--ELIST -> ELIST [322:20]
2975 | | | |--EXPR -> EXPR [322:20]
2976 | | | | `--IDENT -> checkConfig [322:20]
2977 | | | |--COMMA -> , [322:31]
2978 | | | |--EXPR -> EXPR [322:40]
2979 | | | | `--METHOD_CALL -> ( [322:40]
2980 | | | | |--IDENT -> getPath [322:33]
2981 | | | | |--ELIST -> ELIST [322:41]
2982 | | | | | `--EXPR -> EXPR [322:41]
2983 | | | | | `--STRING_LITERAL -> "InputIndentationDifficultAnnotations.java" [322:41]
2984 | | | | `--RPAREN -> ) [322:84]
2985 | | | |--COMMA -> , [322:85]
2986 | | | `--EXPR -> EXPR [322:87]
2987 | | | `--IDENT -> expected [322:87]
2988 | | `--RPAREN -> ) [322:95]
2989 | |--SEMI -> ; [322:96]
2990 | `--RCURLY -> } [323:4]
2991 |--METHOD_DEF -> METHOD_DEF [325:4]
2992 | |--MODIFIERS -> MODIFIERS [325:4]
2993 | | |--ANNOTATION -> ANNOTATION [325:4]
2994 | | | |--AT -> @ [325:4]
2995 | | | `--IDENT -> Test [325:5]
2996 | | `--LITERAL_PUBLIC -> public [326:4]
2997 | |--TYPE -> TYPE [326:11]
2998 | | `--LITERAL_VOID -> void [326:11]
2999 | |--IDENT -> testAnnotationClosingParenthesisEndsInSameIndentationAsOpening [326:16]
3000 | |--LPAREN -> ( [326:78]
3001 | |--PARAMETERS -> PARAMETERS [326:79]
3002 | |--RPAREN -> ) [326:79]
3003 | |--LITERAL_THROWS -> throws [326:81]
3004 | | `--IDENT -> Exception [326:88]
3005 | `--SLIST -> { [326:98]
3006 | |--VARIABLE_DEF -> VARIABLE_DEF [327:8]
3007 | | |--MODIFIERS -> MODIFIERS [327:8]
3008 | | | `--FINAL -> final [327:8]
3009 | | |--TYPE -> TYPE [327:14]
3010 | | | `--IDENT -> DefaultConfiguration [327:14]
3011 | | |--IDENT -> checkConfig [327:35]
3012 | | `--ASSIGN -> = [327:47]
3013 | | `--EXPR -> EXPR [327:67]
3014 | | `--METHOD_CALL -> ( [327:67]
3015 | | |--IDENT -> createModuleConfig [327:49]
3016 | | |--ELIST -> ELIST [327:84]
3017 | | | `--EXPR -> EXPR [327:84]
3018 | | | `--DOT -> . [327:84]
3019 | | | |--IDENT -> IndentationCheck [327:68]
3020 | | | `--LITERAL_CLASS -> class [327:85]
3021 | | `--RPAREN -> ) [327:90]
3022 | |--SEMI -> ; [327:91]
3023 | |--EXPR -> EXPR [329:32]
3024 | | `--METHOD_CALL -> ( [329:32]
3025 | | |--DOT -> . [329:19]
3026 | | | |--IDENT -> checkConfig [329:8]
3027 | | | `--IDENT -> addAttribute [329:20]
3028 | | |--ELIST -> ELIST [329:33]
3029 | | | |--EXPR -> EXPR [329:33]
3030 | | | | `--STRING_LITERAL -> "basicOffset" [329:33]
3031 | | | |--COMMA -> , [329:46]
3032 | | | `--EXPR -> EXPR [329:48]
3033 | | | `--STRING_LITERAL -> "4" [329:48]
3034 | | `--RPAREN -> ) [329:51]
3035 | |--SEMI -> ; [329:52]
3036 | |--EXPR -> EXPR [330:32]
3037 | | `--METHOD_CALL -> ( [330:32]
3038 | | |--DOT -> . [330:19]
3039 | | | |--IDENT -> checkConfig [330:8]
3040 | | | `--IDENT -> addAttribute [330:20]
3041 | | |--ELIST -> ELIST [330:33]
3042 | | | |--EXPR -> EXPR [330:33]
3043 | | | | `--STRING_LITERAL -> "forceStrictCondition" [330:33]
3044 | | | |--COMMA -> , [330:55]
3045 | | | `--EXPR -> EXPR [330:57]
3046 | | | `--STRING_LITERAL -> "true" [330:57]
3047 | | `--RPAREN -> ) [330:63]
3048 | |--SEMI -> ; [330:64]
3049 | |--EXPR -> EXPR [331:32]
3050 | | `--METHOD_CALL -> ( [331:32]
3051 | | |--DOT -> . [331:19]
3052 | | | |--IDENT -> checkConfig [331:8]
3053 | | | `--IDENT -> addAttribute [331:20]
3054 | | |--ELIST -> ELIST [331:33]
3055 | | | |--EXPR -> EXPR [331:33]
3056 | | | | `--STRING_LITERAL -> "tabWidth" [331:33]
3057 | | | |--COMMA -> , [331:43]
3058 | | | `--EXPR -> EXPR [331:45]
3059 | | | `--STRING_LITERAL -> "4" [331:45]
3060 | | `--RPAREN -> ) [331:48]
3061 | |--SEMI -> ; [331:49]
3062 | |--VARIABLE_DEF -> VARIABLE_DEF [333:8]
3063 | | |--MODIFIERS -> MODIFIERS [333:8]
3064 | | | `--FINAL -> final [333:8]
3065 | | |--TYPE -> TYPE [333:20]
3066 | | | `--ARRAY_DECLARATOR -> [ [333:20]
3067 | | | |--IDENT -> String [333:14]
3068 | | | `--RBRACK -> ] [333:21]
3069 | | |--IDENT -> expected [333:23]
3070 | | `--ASSIGN -> = [333:32]
3071 | | `--ARRAY_INIT -> { [333:34]
3072 | | |--EXPR -> EXPR [334:22]
3073 | | | `--PLUS -> + [334:22]
3074 | | | |--STRING_LITERAL -> "34:17: " [334:12]
3075 | | | `--METHOD_CALL -> ( [334:39]
3076 | | | |--IDENT -> getCheckMessage [334:24]
3077 | | | |--ELIST -> ELIST [334:40]
3078 | | | | |--EXPR -> EXPR [334:40]
3079 | | | | | `--IDENT -> MSG_ERROR [334:40]
3080 | | | | |--COMMA -> , [334:49]
3081 | | | | |--EXPR -> EXPR [334:51]
3082 | | | | | `--STRING_LITERAL -> ")" [334:51]
3083 | | | | |--COMMA -> , [334:54]
3084 | | | | |--EXPR -> EXPR [334:56]
3085 | | | | | `--NUM_INT -> 16 [334:56]
3086 | | | | |--COMMA -> , [334:58]
3087 | | | | `--EXPR -> EXPR [334:60]
3088 | | | | `--NUM_INT -> 0 [334:60]
3089 | | | `--RPAREN -> ) [334:61]
3090 | | |--COMMA -> , [334:62]
3091 | | |--EXPR -> EXPR [335:22]
3092 | | | `--PLUS -> + [335:22]
3093 | | | |--STRING_LITERAL -> "36:17: " [335:12]
3094 | | | `--METHOD_CALL -> ( [335:39]
3095 | | | |--IDENT -> getCheckMessage [335:24]
3096 | | | |--ELIST -> ELIST [335:40]
3097 | | | | |--EXPR -> EXPR [335:40]
3098 | | | | | `--IDENT -> MSG_ERROR [335:40]
3099 | | | | |--COMMA -> , [335:49]
3100 | | | | |--EXPR -> EXPR [335:51]
3101 | | | | | `--STRING_LITERAL -> ")" [335:51]
3102 | | | | |--COMMA -> , [335:54]
3103 | | | | |--EXPR -> EXPR [335:56]
3104 | | | | | `--NUM_INT -> 16 [335:56]
3105 | | | | |--COMMA -> , [335:58]
3106 | | | | `--EXPR -> EXPR [335:60]
3107 | | | | `--NUM_INT -> 0 [335:60]
3108 | | | `--RPAREN -> ) [335:61]
3109 | | |--COMMA -> , [335:62]
3110 | | |--EXPR -> EXPR [336:21]
3111 | | | `--PLUS -> + [336:21]
3112 | | | |--STRING_LITERAL -> "40:9: " [336:12]
3113 | | | `--METHOD_CALL -> ( [336:38]
3114 | | | |--IDENT -> getCheckMessage [336:23]
3115 | | | |--ELIST -> ELIST [336:39]
3116 | | | | |--EXPR -> EXPR [336:39]
3117 | | | | | `--IDENT -> MSG_ERROR [336:39]
3118 | | | | |--COMMA -> , [336:48]
3119 | | | | |--EXPR -> EXPR [336:50]
3120 | | | | | `--STRING_LITERAL -> ")" [336:50]
3121 | | | | |--COMMA -> , [336:53]
3122 | | | | |--EXPR -> EXPR [336:55]
3123 | | | | | `--NUM_INT -> 8 [336:55]
3124 | | | | |--COMMA -> , [336:56]
3125 | | | | `--EXPR -> EXPR [336:58]
3126 | | | | `--NUM_INT -> 4 [336:58]
3127 | | | `--RPAREN -> ) [336:59]
3128 | | |--COMMA -> , [336:60]
3129 | | |--EXPR -> EXPR [337:21]
3130 | | | `--PLUS -> + [337:21]
3131 | | | |--STRING_LITERAL -> "42:9: " [337:12]
3132 | | | `--METHOD_CALL -> ( [337:38]
3133 | | | |--IDENT -> getCheckMessage [337:23]
3134 | | | |--ELIST -> ELIST [337:39]
3135 | | | | |--EXPR -> EXPR [337:39]
3136 | | | | | `--IDENT -> MSG_ERROR [337:39]
3137 | | | | |--COMMA -> , [337:48]
3138 | | | | |--EXPR -> EXPR [337:50]
3139 | | | | | `--STRING_LITERAL -> ")" [337:50]
3140 | | | | |--COMMA -> , [337:53]
3141 | | | | |--EXPR -> EXPR [337:55]
3142 | | | | | `--NUM_INT -> 8 [337:55]
3143 | | | | |--COMMA -> , [337:56]
3144 | | | | `--EXPR -> EXPR [337:58]
3145 | | | | `--NUM_INT -> 4 [337:58]
3146 | | | `--RPAREN -> ) [337:59]
3147 | | |--COMMA -> , [337:60]
3148 | | |--EXPR -> EXPR [338:21]
3149 | | | `--PLUS -> + [338:21]
3150 | | | |--STRING_LITERAL -> "46:9: " [338:12]
3151 | | | `--METHOD_CALL -> ( [338:38]
3152 | | | |--IDENT -> getCheckMessage [338:23]
3153 | | | |--ELIST -> ELIST [338:39]
3154 | | | | |--EXPR -> EXPR [338:39]
3155 | | | | | `--IDENT -> MSG_ERROR [338:39]
3156 | | | | |--COMMA -> , [338:48]
3157 | | | | |--EXPR -> EXPR [338:50]
3158 | | | | | `--STRING_LITERAL -> ")" [338:50]
3159 | | | | |--COMMA -> , [338:53]
3160 | | | | |--EXPR -> EXPR [338:55]
3161 | | | | | `--NUM_INT -> 8 [338:55]
3162 | | | | |--COMMA -> , [338:56]
3163 | | | | `--EXPR -> EXPR [338:58]
3164 | | | | `--NUM_INT -> 4 [338:58]
3165 | | | `--RPAREN -> ) [338:59]
3166 | | |--COMMA -> , [338:60]
3167 | | `--RCURLY -> } [339:8]
3168 | |--SEMI -> ; [339:9]
3169 | |--EXPR -> EXPR [341:19]
3170 | | `--METHOD_CALL -> ( [341:19]
3171 | | |--IDENT -> verifyWarns [341:8]
3172 | | |--ELIST -> ELIST [341:20]
3173 | | | |--EXPR -> EXPR [341:20]
3174 | | | | `--IDENT -> checkConfig [341:20]
3175 | | | |--COMMA -> , [341:31]
3176 | | | |--EXPR -> EXPR [342:19]
3177 | | | | `--METHOD_CALL -> ( [342:19]
3178 | | | | |--IDENT -> getPath [342:12]
3179 | | | | |--ELIST -> ELIST [343:16]
3180 | | | | | `--EXPR -> EXPR [343:16]
3181 | | | | | `--PLUS -> + [343:16]
3182 | | | | | |--STRING_LITERAL -> "InputIndentation" [342:20]
3183 | | | | | `--STRING_LITERAL -> "AnnotationClosingParenthesisEndsInSameIndentationAsOpening.java" [343:18]
3184 | | | | `--RPAREN -> ) [343:83]
3185 | | | |--COMMA -> , [343:84]
3186 | | | `--EXPR -> EXPR [344:16]
3187 | | | `--IDENT -> expected [344:16]
3188 | | `--RPAREN -> ) [344:24]
3189 | |--SEMI -> ; [344:25]
3190 | `--RCURLY -> } [345:4]
3191 |--METHOD_DEF -> METHOD_DEF [347:4]
3192 | |--MODIFIERS -> MODIFIERS [347:4]
3193 | | |--ANNOTATION -> ANNOTATION [347:4]
3194 | | | |--AT -> @ [347:4]
3195 | | | `--IDENT -> Test [347:5]
3196 | | `--LITERAL_PUBLIC -> public [348:4]
3197 | |--TYPE -> TYPE [348:11]
3198 | | `--LITERAL_VOID -> void [348:11]
3199 | |--IDENT -> testAnonClassesFromGuava [348:16]
3200 | |--LPAREN -> ( [348:40]
3201 | |--PARAMETERS -> PARAMETERS [348:41]
3202 | |--RPAREN -> ) [348:41]
3203 | |--LITERAL_THROWS -> throws [348:43]
3204 | | `--IDENT -> Exception [348:50]
3205 | `--SLIST -> { [348:60]
3206 | |--VARIABLE_DEF -> VARIABLE_DEF [349:8]
3207 | | |--MODIFIERS -> MODIFIERS [349:8]
3208 | | | `--FINAL -> final [349:8]
3209 | | |--TYPE -> TYPE [349:14]
3210 | | | `--IDENT -> DefaultConfiguration [349:14]
3211 | | |--IDENT -> checkConfig [349:35]
3212 | | `--ASSIGN -> = [349:47]
3213 | | `--EXPR -> EXPR [349:67]
3214 | | `--METHOD_CALL -> ( [349:67]
3215 | | |--IDENT -> createModuleConfig [349:49]
3216 | | |--ELIST -> ELIST [349:84]
3217 | | | `--EXPR -> EXPR [349:84]
3218 | | | `--DOT -> . [349:84]
3219 | | | |--IDENT -> IndentationCheck [349:68]
3220 | | | `--LITERAL_CLASS -> class [349:85]
3221 | | `--RPAREN -> ) [349:90]
3222 | |--SEMI -> ; [349:91]
3223 | |--EXPR -> EXPR [351:32]
3224 | | `--METHOD_CALL -> ( [351:32]
3225 | | |--DOT -> . [351:19]
3226 | | | |--IDENT -> checkConfig [351:8]
3227 | | | `--IDENT -> addAttribute [351:20]
3228 | | |--ELIST -> ELIST [351:33]
3229 | | | |--EXPR -> EXPR [351:33]
3230 | | | | `--STRING_LITERAL -> "arrayInitIndent" [351:33]
3231 | | | |--COMMA -> , [351:50]
3232 | | | `--EXPR -> EXPR [351:52]
3233 | | | `--STRING_LITERAL -> "4" [351:52]
3234 | | `--RPAREN -> ) [351:55]
3235 | |--SEMI -> ; [351:56]
3236 | |--EXPR -> EXPR [352:32]
3237 | | `--METHOD_CALL -> ( [352:32]
3238 | | |--DOT -> . [352:19]
3239 | | | |--IDENT -> checkConfig [352:8]
3240 | | | `--IDENT -> addAttribute [352:20]
3241 | | |--ELIST -> ELIST [352:33]
3242 | | | |--EXPR -> EXPR [352:33]
3243 | | | | `--STRING_LITERAL -> "basicOffset" [352:33]
3244 | | | |--COMMA -> , [352:46]
3245 | | | `--EXPR -> EXPR [352:48]
3246 | | | `--STRING_LITERAL -> "2" [352:48]
3247 | | `--RPAREN -> ) [352:51]
3248 | |--SEMI -> ; [352:52]
3249 | |--EXPR -> EXPR [353:32]
3250 | | `--METHOD_CALL -> ( [353:32]
3251 | | |--DOT -> . [353:19]
3252 | | | |--IDENT -> checkConfig [353:8]
3253 | | | `--IDENT -> addAttribute [353:20]
3254 | | |--ELIST -> ELIST [353:33]
3255 | | | |--EXPR -> EXPR [353:33]
3256 | | | | `--STRING_LITERAL -> "braceAdjustment" [353:33]
3257 | | | |--COMMA -> , [353:50]
3258 | | | `--EXPR -> EXPR [353:52]
3259 | | | `--STRING_LITERAL -> "0" [353:52]
3260 | | `--RPAREN -> ) [353:55]
3261 | |--SEMI -> ; [353:56]
3262 | |--EXPR -> EXPR [354:32]
3263 | | `--METHOD_CALL -> ( [354:32]
3264 | | |--DOT -> . [354:19]
3265 | | | |--IDENT -> checkConfig [354:8]
3266 | | | `--IDENT -> addAttribute [354:20]
3267 | | |--ELIST -> ELIST [354:33]
3268 | | | |--EXPR -> EXPR [354:33]
3269 | | | | `--STRING_LITERAL -> "caseIndent" [354:33]
3270 | | | |--COMMA -> , [354:45]
3271 | | | `--EXPR -> EXPR [354:47]
3272 | | | `--STRING_LITERAL -> "4" [354:47]
3273 | | `--RPAREN -> ) [354:50]
3274 | |--SEMI -> ; [354:51]
3275 | |--EXPR -> EXPR [355:32]
3276 | | `--METHOD_CALL -> ( [355:32]
3277 | | |--DOT -> . [355:19]
3278 | | | |--IDENT -> checkConfig [355:8]
3279 | | | `--IDENT -> addAttribute [355:20]
3280 | | |--ELIST -> ELIST [355:33]
3281 | | | |--EXPR -> EXPR [355:33]
3282 | | | | `--STRING_LITERAL -> "forceStrictCondition" [355:33]
3283 | | | |--COMMA -> , [355:55]
3284 | | | `--EXPR -> EXPR [355:57]
3285 | | | `--STRING_LITERAL -> "false" [355:57]
3286 | | `--RPAREN -> ) [355:64]
3287 | |--SEMI -> ; [355:65]
3288 | |--EXPR -> EXPR [356:32]
3289 | | `--METHOD_CALL -> ( [356:32]
3290 | | |--DOT -> . [356:19]
3291 | | | |--IDENT -> checkConfig [356:8]
3292 | | | `--IDENT -> addAttribute [356:20]
3293 | | |--ELIST -> ELIST [356:33]
3294 | | | |--EXPR -> EXPR [356:33]
3295 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [356:33]
3296 | | | |--COMMA -> , [356:58]
3297 | | | `--EXPR -> EXPR [356:60]
3298 | | | `--STRING_LITERAL -> "4" [356:60]
3299 | | `--RPAREN -> ) [356:63]
3300 | |--SEMI -> ; [356:64]
3301 | |--EXPR -> EXPR [357:32]
3302 | | `--METHOD_CALL -> ( [357:32]
3303 | | |--DOT -> . [357:19]
3304 | | | |--IDENT -> checkConfig [357:8]
3305 | | | `--IDENT -> addAttribute [357:20]
3306 | | |--ELIST -> ELIST [357:33]
3307 | | | |--EXPR -> EXPR [357:33]
3308 | | | | `--STRING_LITERAL -> "tabWidth" [357:33]
3309 | | | |--COMMA -> , [357:43]
3310 | | | `--EXPR -> EXPR [357:45]
3311 | | | `--STRING_LITERAL -> "4" [357:45]
3312 | | `--RPAREN -> ) [357:48]
3313 | |--SEMI -> ; [357:49]
3314 | |--EXPR -> EXPR [358:32]
3315 | | `--METHOD_CALL -> ( [358:32]
3316 | | |--DOT -> . [358:19]
3317 | | | |--IDENT -> checkConfig [358:8]
3318 | | | `--IDENT -> addAttribute [358:20]
3319 | | |--ELIST -> ELIST [358:33]
3320 | | | |--EXPR -> EXPR [358:33]
3321 | | | | `--STRING_LITERAL -> "throwsIndent" [358:33]
3322 | | | |--COMMA -> , [358:47]
3323 | | | `--EXPR -> EXPR [358:49]
3324 | | | `--STRING_LITERAL -> "4" [358:49]
3325 | | `--RPAREN -> ) [358:52]
3326 | |--SEMI -> ; [358:53]
3327 | |--VARIABLE_DEF -> VARIABLE_DEF [359:8]
3328 | | |--MODIFIERS -> MODIFIERS [359:8]
3329 | | | `--FINAL -> final [359:8]
3330 | | |--TYPE -> TYPE [359:20]
3331 | | | `--ARRAY_DECLARATOR -> [ [359:20]
3332 | | | |--IDENT -> String [359:14]
3333 | | | `--RBRACK -> ] [359:21]
3334 | | |--IDENT -> expected [359:23]
3335 | | `--ASSIGN -> = [359:32]
3336 | | `--EXPR -> EXPR [359:44]
3337 | | `--DOT -> . [359:44]
3338 | | |--IDENT -> CommonUtil [359:34]
3339 | | `--IDENT -> EMPTY_STRING_ARRAY [359:45]
3340 | |--SEMI -> ; [359:63]
3341 | |--EXPR -> EXPR [360:19]
3342 | | `--METHOD_CALL -> ( [360:19]
3343 | | |--IDENT -> verifyWarns [360:8]
3344 | | |--ELIST -> ELIST [360:20]
3345 | | | |--EXPR -> EXPR [360:20]
3346 | | | | `--IDENT -> checkConfig [360:20]
3347 | | | |--COMMA -> , [360:31]
3348 | | | |--EXPR -> EXPR [360:40]
3349 | | | | `--METHOD_CALL -> ( [360:40]
3350 | | | | |--IDENT -> getPath [360:33]
3351 | | | | |--ELIST -> ELIST [360:41]
3352 | | | | | `--EXPR -> EXPR [360:41]
3353 | | | | | `--STRING_LITERAL -> "InputIndentationFromGuava2.java" [360:41]
3354 | | | | `--RPAREN -> ) [360:74]
3355 | | | |--COMMA -> , [360:75]
3356 | | | `--EXPR -> EXPR [360:77]
3357 | | | `--IDENT -> expected [360:77]
3358 | | `--RPAREN -> ) [360:85]
3359 | |--SEMI -> ; [360:86]
3360 | `--RCURLY -> } [361:4]
3361 |--METHOD_DEF -> METHOD_DEF [363:4]
3362 | |--MODIFIERS -> MODIFIERS [363:4]
3363 | | |--ANNOTATION -> ANNOTATION [363:4]
3364 | | | |--AT -> @ [363:4]
3365 | | | `--IDENT -> Test [363:5]
3366 | | `--LITERAL_PUBLIC -> public [364:4]
3367 | |--TYPE -> TYPE [364:11]
3368 | | `--LITERAL_VOID -> void [364:11]
3369 | |--IDENT -> testAnnotations [364:16]
3370 | |--LPAREN -> ( [364:31]
3371 | |--PARAMETERS -> PARAMETERS [364:32]
3372 | |--RPAREN -> ) [364:32]
3373 | |--LITERAL_THROWS -> throws [364:34]
3374 | | `--IDENT -> Exception [364:41]
3375 | `--SLIST -> { [364:51]
3376 | |--VARIABLE_DEF -> VARIABLE_DEF [365:8]
3377 | | |--MODIFIERS -> MODIFIERS [365:8]
3378 | | | `--FINAL -> final [365:8]
3379 | | |--TYPE -> TYPE [365:14]
3380 | | | `--IDENT -> DefaultConfiguration [365:14]
3381 | | |--IDENT -> checkConfig [365:35]
3382 | | `--ASSIGN -> = [365:47]
3383 | | `--EXPR -> EXPR [365:67]
3384 | | `--METHOD_CALL -> ( [365:67]
3385 | | |--IDENT -> createModuleConfig [365:49]
3386 | | |--ELIST -> ELIST [365:84]
3387 | | | `--EXPR -> EXPR [365:84]
3388 | | | `--DOT -> . [365:84]
3389 | | | |--IDENT -> IndentationCheck [365:68]
3390 | | | `--LITERAL_CLASS -> class [365:85]
3391 | | `--RPAREN -> ) [365:90]
3392 | |--SEMI -> ; [365:91]
3393 | |--EXPR -> EXPR [367:32]
3394 | | `--METHOD_CALL -> ( [367:32]
3395 | | |--DOT -> . [367:19]
3396 | | | |--IDENT -> checkConfig [367:8]
3397 | | | `--IDENT -> addAttribute [367:20]
3398 | | |--ELIST -> ELIST [367:33]
3399 | | | |--EXPR -> EXPR [367:33]
3400 | | | | `--STRING_LITERAL -> "arrayInitIndent" [367:33]
3401 | | | |--COMMA -> , [367:50]
3402 | | | `--EXPR -> EXPR [367:52]
3403 | | | `--STRING_LITERAL -> "4" [367:52]
3404 | | `--RPAREN -> ) [367:55]
3405 | |--SEMI -> ; [367:56]
3406 | |--EXPR -> EXPR [368:32]
3407 | | `--METHOD_CALL -> ( [368:32]
3408 | | |--DOT -> . [368:19]
3409 | | | |--IDENT -> checkConfig [368:8]
3410 | | | `--IDENT -> addAttribute [368:20]
3411 | | |--ELIST -> ELIST [368:33]
3412 | | | |--EXPR -> EXPR [368:33]
3413 | | | | `--STRING_LITERAL -> "basicOffset" [368:33]
3414 | | | |--COMMA -> , [368:46]
3415 | | | `--EXPR -> EXPR [368:48]
3416 | | | `--STRING_LITERAL -> "2" [368:48]
3417 | | `--RPAREN -> ) [368:51]
3418 | |--SEMI -> ; [368:52]
3419 | |--EXPR -> EXPR [369:32]
3420 | | `--METHOD_CALL -> ( [369:32]
3421 | | |--DOT -> . [369:19]
3422 | | | |--IDENT -> checkConfig [369:8]
3423 | | | `--IDENT -> addAttribute [369:20]
3424 | | |--ELIST -> ELIST [369:33]
3425 | | | |--EXPR -> EXPR [369:33]
3426 | | | | `--STRING_LITERAL -> "braceAdjustment" [369:33]
3427 | | | |--COMMA -> , [369:50]
3428 | | | `--EXPR -> EXPR [369:52]
3429 | | | `--STRING_LITERAL -> "0" [369:52]
3430 | | `--RPAREN -> ) [369:55]
3431 | |--SEMI -> ; [369:56]
3432 | |--EXPR -> EXPR [370:32]
3433 | | `--METHOD_CALL -> ( [370:32]
3434 | | |--DOT -> . [370:19]
3435 | | | |--IDENT -> checkConfig [370:8]
3436 | | | `--IDENT -> addAttribute [370:20]
3437 | | |--ELIST -> ELIST [370:33]
3438 | | | |--EXPR -> EXPR [370:33]
3439 | | | | `--STRING_LITERAL -> "caseIndent" [370:33]
3440 | | | |--COMMA -> , [370:45]
3441 | | | `--EXPR -> EXPR [370:47]
3442 | | | `--STRING_LITERAL -> "4" [370:47]
3443 | | `--RPAREN -> ) [370:50]
3444 | |--SEMI -> ; [370:51]
3445 | |--EXPR -> EXPR [371:32]
3446 | | `--METHOD_CALL -> ( [371:32]
3447 | | |--DOT -> . [371:19]
3448 | | | |--IDENT -> checkConfig [371:8]
3449 | | | `--IDENT -> addAttribute [371:20]
3450 | | |--ELIST -> ELIST [371:33]
3451 | | | |--EXPR -> EXPR [371:33]
3452 | | | | `--STRING_LITERAL -> "forceStrictCondition" [371:33]
3453 | | | |--COMMA -> , [371:55]
3454 | | | `--EXPR -> EXPR [371:57]
3455 | | | `--STRING_LITERAL -> "false" [371:57]
3456 | | `--RPAREN -> ) [371:64]
3457 | |--SEMI -> ; [371:65]
3458 | |--EXPR -> EXPR [372:32]
3459 | | `--METHOD_CALL -> ( [372:32]
3460 | | |--DOT -> . [372:19]
3461 | | | |--IDENT -> checkConfig [372:8]
3462 | | | `--IDENT -> addAttribute [372:20]
3463 | | |--ELIST -> ELIST [372:33]
3464 | | | |--EXPR -> EXPR [372:33]
3465 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [372:33]
3466 | | | |--COMMA -> , [372:58]
3467 | | | `--EXPR -> EXPR [372:60]
3468 | | | `--STRING_LITERAL -> "4" [372:60]
3469 | | `--RPAREN -> ) [372:63]
3470 | |--SEMI -> ; [372:64]
3471 | |--EXPR -> EXPR [373:32]
3472 | | `--METHOD_CALL -> ( [373:32]
3473 | | |--DOT -> . [373:19]
3474 | | | |--IDENT -> checkConfig [373:8]
3475 | | | `--IDENT -> addAttribute [373:20]
3476 | | |--ELIST -> ELIST [373:33]
3477 | | | |--EXPR -> EXPR [373:33]
3478 | | | | `--STRING_LITERAL -> "tabWidth" [373:33]
3479 | | | |--COMMA -> , [373:43]
3480 | | | `--EXPR -> EXPR [373:45]
3481 | | | `--STRING_LITERAL -> "4" [373:45]
3482 | | `--RPAREN -> ) [373:48]
3483 | |--SEMI -> ; [373:49]
3484 | |--EXPR -> EXPR [374:32]
3485 | | `--METHOD_CALL -> ( [374:32]
3486 | | |--DOT -> . [374:19]
3487 | | | |--IDENT -> checkConfig [374:8]
3488 | | | `--IDENT -> addAttribute [374:20]
3489 | | |--ELIST -> ELIST [374:33]
3490 | | | |--EXPR -> EXPR [374:33]
3491 | | | | `--STRING_LITERAL -> "throwsIndent" [374:33]
3492 | | | |--COMMA -> , [374:47]
3493 | | | `--EXPR -> EXPR [374:49]
3494 | | | `--STRING_LITERAL -> "4" [374:49]
3495 | | `--RPAREN -> ) [374:52]
3496 | |--SEMI -> ; [374:53]
3497 | |--VARIABLE_DEF -> VARIABLE_DEF [375:8]
3498 | | |--MODIFIERS -> MODIFIERS [375:8]
3499 | | | `--FINAL -> final [375:8]
3500 | | |--TYPE -> TYPE [375:20]
3501 | | | `--ARRAY_DECLARATOR -> [ [375:20]
3502 | | | |--IDENT -> String [375:14]
3503 | | | `--RBRACK -> ] [375:21]
3504 | | |--IDENT -> expected [375:23]
3505 | | `--ASSIGN -> = [375:32]
3506 | | `--EXPR -> EXPR [375:44]
3507 | | `--DOT -> . [375:44]
3508 | | |--IDENT -> CommonUtil [375:34]
3509 | | `--IDENT -> EMPTY_STRING_ARRAY [375:45]
3510 | |--SEMI -> ; [375:63]
3511 | |--EXPR -> EXPR [376:19]
3512 | | `--METHOD_CALL -> ( [376:19]
3513 | | |--IDENT -> verifyWarns [376:8]
3514 | | |--ELIST -> ELIST [376:20]
3515 | | | |--EXPR -> EXPR [376:20]
3516 | | | | `--IDENT -> checkConfig [376:20]
3517 | | | |--COMMA -> , [376:31]
3518 | | | |--EXPR -> EXPR [376:40]
3519 | | | | `--METHOD_CALL -> ( [376:40]
3520 | | | | |--IDENT -> getPath [376:33]
3521 | | | | |--ELIST -> ELIST [376:41]
3522 | | | | | `--EXPR -> EXPR [376:41]
3523 | | | | | `--STRING_LITERAL -> "InputIndentationFromGuava.java" [376:41]
3524 | | | | `--RPAREN -> ) [376:73]
3525 | | | |--COMMA -> , [376:74]
3526 | | | `--EXPR -> EXPR [376:76]
3527 | | | `--IDENT -> expected [376:76]
3528 | | `--RPAREN -> ) [376:84]
3529 | |--SEMI -> ; [376:85]
3530 | `--RCURLY -> } [377:4]
3531 |--METHOD_DEF -> METHOD_DEF [379:4]
3532 | |--MODIFIERS -> MODIFIERS [379:4]
3533 | | |--ANNOTATION -> ANNOTATION [379:4]
3534 | | | |--AT -> @ [379:4]
3535 | | | `--IDENT -> Test [379:5]
3536 | | `--LITERAL_PUBLIC -> public [380:4]
3537 | |--TYPE -> TYPE [380:11]
3538 | | `--LITERAL_VOID -> void [380:11]
3539 | |--IDENT -> testCorrectIfAndParameters [380:16]
3540 | |--LPAREN -> ( [380:42]
3541 | |--PARAMETERS -> PARAMETERS [380:43]
3542 | |--RPAREN -> ) [380:43]
3543 | |--LITERAL_THROWS -> throws [380:45]
3544 | | `--IDENT -> Exception [380:52]
3545 | `--SLIST -> { [380:62]
3546 | |--VARIABLE_DEF -> VARIABLE_DEF [381:8]
3547 | | |--MODIFIERS -> MODIFIERS [381:8]
3548 | | | `--FINAL -> final [381:8]
3549 | | |--TYPE -> TYPE [381:14]
3550 | | | `--IDENT -> DefaultConfiguration [381:14]
3551 | | |--IDENT -> checkConfig [381:35]
3552 | | `--ASSIGN -> = [381:47]
3553 | | `--EXPR -> EXPR [381:67]
3554 | | `--METHOD_CALL -> ( [381:67]
3555 | | |--IDENT -> createModuleConfig [381:49]
3556 | | |--ELIST -> ELIST [381:84]
3557 | | | `--EXPR -> EXPR [381:84]
3558 | | | `--DOT -> . [381:84]
3559 | | | |--IDENT -> IndentationCheck [381:68]
3560 | | | `--LITERAL_CLASS -> class [381:85]
3561 | | `--RPAREN -> ) [381:90]
3562 | |--SEMI -> ; [381:91]
3563 | |--EXPR -> EXPR [383:32]
3564 | | `--METHOD_CALL -> ( [383:32]
3565 | | |--DOT -> . [383:19]
3566 | | | |--IDENT -> checkConfig [383:8]
3567 | | | `--IDENT -> addAttribute [383:20]
3568 | | |--ELIST -> ELIST [383:33]
3569 | | | |--EXPR -> EXPR [383:33]
3570 | | | | `--STRING_LITERAL -> "arrayInitIndent" [383:33]
3571 | | | |--COMMA -> , [383:50]
3572 | | | `--EXPR -> EXPR [383:52]
3573 | | | `--STRING_LITERAL -> "4" [383:52]
3574 | | `--RPAREN -> ) [383:55]
3575 | |--SEMI -> ; [383:56]
3576 | |--EXPR -> EXPR [384:32]
3577 | | `--METHOD_CALL -> ( [384:32]
3578 | | |--DOT -> . [384:19]
3579 | | | |--IDENT -> checkConfig [384:8]
3580 | | | `--IDENT -> addAttribute [384:20]
3581 | | |--ELIST -> ELIST [384:33]
3582 | | | |--EXPR -> EXPR [384:33]
3583 | | | | `--STRING_LITERAL -> "basicOffset" [384:33]
3584 | | | |--COMMA -> , [384:46]
3585 | | | `--EXPR -> EXPR [384:48]
3586 | | | `--STRING_LITERAL -> "2" [384:48]
3587 | | `--RPAREN -> ) [384:51]
3588 | |--SEMI -> ; [384:52]
3589 | |--EXPR -> EXPR [385:32]
3590 | | `--METHOD_CALL -> ( [385:32]
3591 | | |--DOT -> . [385:19]
3592 | | | |--IDENT -> checkConfig [385:8]
3593 | | | `--IDENT -> addAttribute [385:20]
3594 | | |--ELIST -> ELIST [385:33]
3595 | | | |--EXPR -> EXPR [385:33]
3596 | | | | `--STRING_LITERAL -> "braceAdjustment" [385:33]
3597 | | | |--COMMA -> , [385:50]
3598 | | | `--EXPR -> EXPR [385:52]
3599 | | | `--STRING_LITERAL -> "0" [385:52]
3600 | | `--RPAREN -> ) [385:55]
3601 | |--SEMI -> ; [385:56]
3602 | |--EXPR -> EXPR [386:32]
3603 | | `--METHOD_CALL -> ( [386:32]
3604 | | |--DOT -> . [386:19]
3605 | | | |--IDENT -> checkConfig [386:8]
3606 | | | `--IDENT -> addAttribute [386:20]
3607 | | |--ELIST -> ELIST [386:33]
3608 | | | |--EXPR -> EXPR [386:33]
3609 | | | | `--STRING_LITERAL -> "caseIndent" [386:33]
3610 | | | |--COMMA -> , [386:45]
3611 | | | `--EXPR -> EXPR [386:47]
3612 | | | `--STRING_LITERAL -> "4" [386:47]
3613 | | `--RPAREN -> ) [386:50]
3614 | |--SEMI -> ; [386:51]
3615 | |--EXPR -> EXPR [387:32]
3616 | | `--METHOD_CALL -> ( [387:32]
3617 | | |--DOT -> . [387:19]
3618 | | | |--IDENT -> checkConfig [387:8]
3619 | | | `--IDENT -> addAttribute [387:20]
3620 | | |--ELIST -> ELIST [387:33]
3621 | | | |--EXPR -> EXPR [387:33]
3622 | | | | `--STRING_LITERAL -> "forceStrictCondition" [387:33]
3623 | | | |--COMMA -> , [387:55]
3624 | | | `--EXPR -> EXPR [387:57]
3625 | | | `--STRING_LITERAL -> "false" [387:57]
3626 | | `--RPAREN -> ) [387:64]
3627 | |--SEMI -> ; [387:65]
3628 | |--EXPR -> EXPR [388:32]
3629 | | `--METHOD_CALL -> ( [388:32]
3630 | | |--DOT -> . [388:19]
3631 | | | |--IDENT -> checkConfig [388:8]
3632 | | | `--IDENT -> addAttribute [388:20]
3633 | | |--ELIST -> ELIST [388:33]
3634 | | | |--EXPR -> EXPR [388:33]
3635 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [388:33]
3636 | | | |--COMMA -> , [388:58]
3637 | | | `--EXPR -> EXPR [388:60]
3638 | | | `--STRING_LITERAL -> "4" [388:60]
3639 | | `--RPAREN -> ) [388:63]
3640 | |--SEMI -> ; [388:64]
3641 | |--EXPR -> EXPR [389:32]
3642 | | `--METHOD_CALL -> ( [389:32]
3643 | | |--DOT -> . [389:19]
3644 | | | |--IDENT -> checkConfig [389:8]
3645 | | | `--IDENT -> addAttribute [389:20]
3646 | | |--ELIST -> ELIST [389:33]
3647 | | | |--EXPR -> EXPR [389:33]
3648 | | | | `--STRING_LITERAL -> "tabWidth" [389:33]
3649 | | | |--COMMA -> , [389:43]
3650 | | | `--EXPR -> EXPR [389:45]
3651 | | | `--STRING_LITERAL -> "4" [389:45]
3652 | | `--RPAREN -> ) [389:48]
3653 | |--SEMI -> ; [389:49]
3654 | |--EXPR -> EXPR [390:32]
3655 | | `--METHOD_CALL -> ( [390:32]
3656 | | |--DOT -> . [390:19]
3657 | | | |--IDENT -> checkConfig [390:8]
3658 | | | `--IDENT -> addAttribute [390:20]
3659 | | |--ELIST -> ELIST [390:33]
3660 | | | |--EXPR -> EXPR [390:33]
3661 | | | | `--STRING_LITERAL -> "throwsIndent" [390:33]
3662 | | | |--COMMA -> , [390:47]
3663 | | | `--EXPR -> EXPR [390:49]
3664 | | | `--STRING_LITERAL -> "4" [390:49]
3665 | | `--RPAREN -> ) [390:52]
3666 | |--SEMI -> ; [390:53]
3667 | |--VARIABLE_DEF -> VARIABLE_DEF [391:8]
3668 | | |--MODIFIERS -> MODIFIERS [391:8]
3669 | | | `--FINAL -> final [391:8]
3670 | | |--TYPE -> TYPE [391:20]
3671 | | | `--ARRAY_DECLARATOR -> [ [391:20]
3672 | | | |--IDENT -> String [391:14]
3673 | | | `--RBRACK -> ] [391:21]
3674 | | |--IDENT -> expected [391:23]
3675 | | `--ASSIGN -> = [391:32]
3676 | | `--ARRAY_INIT -> { [391:34]
3677 | | |--EXPR -> EXPR [392:21]
3678 | | | `--PLUS -> + [392:21]
3679 | | | |--STRING_LITERAL -> "33:9: " [392:12]
3680 | | | `--METHOD_CALL -> ( [392:38]
3681 | | | |--IDENT -> getCheckMessage [392:23]
3682 | | | |--ELIST -> ELIST [392:39]
3683 | | | | |--EXPR -> EXPR [392:39]
3684 | | | | | `--IDENT -> MSG_ERROR_MULTI [392:39]
3685 | | | | |--COMMA -> , [392:54]
3686 | | | | |--EXPR -> EXPR [392:56]
3687 | | | | | `--STRING_LITERAL -> "new" [392:56]
3688 | | | | |--COMMA -> , [392:61]
3689 | | | | |--EXPR -> EXPR [392:63]
3690 | | | | | `--NUM_INT -> 8 [392:63]
3691 | | | | |--COMMA -> , [392:64]
3692 | | | | `--EXPR -> EXPR [392:66]
3693 | | | | `--STRING_LITERAL -> "10, 12" [392:66]
3694 | | | `--RPAREN -> ) [392:74]
3695 | | |--COMMA -> , [392:75]
3696 | | |--EXPR -> EXPR [393:21]
3697 | | | `--PLUS -> + [393:21]
3698 | | | |--STRING_LITERAL -> "40:9: " [393:12]
3699 | | | `--METHOD_CALL -> ( [393:38]
3700 | | | |--IDENT -> getCheckMessage [393:23]
3701 | | | |--ELIST -> ELIST [393:39]
3702 | | | | |--EXPR -> EXPR [393:39]
3703 | | | | | `--IDENT -> MSG_ERROR_MULTI [393:39]
3704 | | | | |--COMMA -> , [393:54]
3705 | | | | |--EXPR -> EXPR [393:56]
3706 | | | | | `--STRING_LITERAL -> "new" [393:56]
3707 | | | | |--COMMA -> , [393:61]
3708 | | | | |--EXPR -> EXPR [393:63]
3709 | | | | | `--NUM_INT -> 8 [393:63]
3710 | | | | |--COMMA -> , [393:64]
3711 | | | | `--EXPR -> EXPR [393:66]
3712 | | | | `--STRING_LITERAL -> "10, 12" [393:66]
3713 | | | `--RPAREN -> ) [393:74]
3714 | | |--COMMA -> , [393:75]
3715 | | |--EXPR -> EXPR [394:22]
3716 | | | `--PLUS -> + [394:22]
3717 | | | |--STRING_LITERAL -> "90:11: " [394:12]
3718 | | | `--METHOD_CALL -> ( [394:39]
3719 | | | |--IDENT -> getCheckMessage [394:24]
3720 | | | |--ELIST -> ELIST [394:40]
3721 | | | | |--EXPR -> EXPR [394:40]
3722 | | | | | `--IDENT -> MSG_ERROR_MULTI [394:40]
3723 | | | | |--COMMA -> , [394:55]
3724 | | | | |--EXPR -> EXPR [394:57]
3725 | | | | | `--STRING_LITERAL -> "new" [394:57]
3726 | | | | |--COMMA -> , [394:62]
3727 | | | | |--EXPR -> EXPR [394:64]
3728 | | | | | `--NUM_INT -> 10 [394:64]
3729 | | | | |--COMMA -> , [394:66]
3730 | | | | `--EXPR -> EXPR [394:68]
3731 | | | | `--STRING_LITERAL -> "12, 14" [394:68]
3732 | | | `--RPAREN -> ) [394:76]
3733 | | |--COMMA -> , [394:77]
3734 | | |--EXPR -> EXPR [395:22]
3735 | | | `--PLUS -> + [395:22]
3736 | | | |--STRING_LITERAL -> "97:13: " [395:12]
3737 | | | `--METHOD_CALL -> ( [395:39]
3738 | | | |--IDENT -> getCheckMessage [395:24]
3739 | | | |--ELIST -> ELIST [395:40]
3740 | | | | |--EXPR -> EXPR [395:40]
3741 | | | | | `--IDENT -> MSG_ERROR_MULTI [395:40]
3742 | | | | |--COMMA -> , [395:55]
3743 | | | | |--EXPR -> EXPR [395:57]
3744 | | | | | `--STRING_LITERAL -> "new" [395:57]
3745 | | | | |--COMMA -> , [395:62]
3746 | | | | |--EXPR -> EXPR [395:64]
3747 | | | | | `--NUM_INT -> 12 [395:64]
3748 | | | | |--COMMA -> , [395:66]
3749 | | | | `--EXPR -> EXPR [395:68]
3750 | | | | `--STRING_LITERAL -> "14, 16" [395:68]
3751 | | | `--RPAREN -> ) [395:76]
3752 | | |--COMMA -> , [395:77]
3753 | | |--EXPR -> EXPR [396:23]
3754 | | | `--PLUS -> + [396:23]
3755 | | | |--STRING_LITERAL -> "119:13: " [396:12]
3756 | | | `--METHOD_CALL -> ( [396:40]
3757 | | | |--IDENT -> getCheckMessage [396:25]
3758 | | | |--ELIST -> ELIST [396:41]
3759 | | | | |--EXPR -> EXPR [396:41]
3760 | | | | | `--IDENT -> MSG_ERROR_MULTI [396:41]
3761 | | | | |--COMMA -> , [396:56]
3762 | | | | |--EXPR -> EXPR [396:58]
3763 | | | | | `--STRING_LITERAL -> "new" [396:58]
3764 | | | | |--COMMA -> , [396:63]
3765 | | | | |--EXPR -> EXPR [396:65]
3766 | | | | | `--NUM_INT -> 12 [396:65]
3767 | | | | |--COMMA -> , [396:67]
3768 | | | | `--EXPR -> EXPR [396:69]
3769 | | | | `--STRING_LITERAL -> "14, 16" [396:69]
3770 | | | `--RPAREN -> ) [396:77]
3771 | | |--COMMA -> , [396:78]
3772 | | |--EXPR -> EXPR [397:23]
3773 | | | `--PLUS -> + [397:23]
3774 | | | |--STRING_LITERAL -> "126:15: " [397:12]
3775 | | | `--METHOD_CALL -> ( [397:40]
3776 | | | |--IDENT -> getCheckMessage [397:25]
3777 | | | |--ELIST -> ELIST [397:41]
3778 | | | | |--EXPR -> EXPR [397:41]
3779 | | | | | `--IDENT -> MSG_ERROR_MULTI [397:41]
3780 | | | | |--COMMA -> , [397:56]
3781 | | | | |--EXPR -> EXPR [397:58]
3782 | | | | | `--STRING_LITERAL -> "new" [397:58]
3783 | | | | |--COMMA -> , [397:63]
3784 | | | | |--EXPR -> EXPR [397:65]
3785 | | | | | `--NUM_INT -> 14 [397:65]
3786 | | | | |--COMMA -> , [397:67]
3787 | | | | `--EXPR -> EXPR [397:69]
3788 | | | | `--STRING_LITERAL -> "16, 18" [397:69]
3789 | | | `--RPAREN -> ) [397:77]
3790 | | |--COMMA -> , [397:78]
3791 | | `--RCURLY -> } [398:8]
3792 | |--SEMI -> ; [398:9]
3793 | |--EXPR -> EXPR [399:19]
3794 | | `--METHOD_CALL -> ( [399:19]
3795 | | |--IDENT -> verifyWarns [399:8]
3796 | | |--ELIST -> ELIST [399:20]
3797 | | | |--EXPR -> EXPR [399:20]
3798 | | | | `--IDENT -> checkConfig [399:20]
3799 | | | |--COMMA -> , [399:31]
3800 | | | |--EXPR -> EXPR [399:40]
3801 | | | | `--METHOD_CALL -> ( [399:40]
3802 | | | | |--IDENT -> getPath [399:33]
3803 | | | | |--ELIST -> ELIST [399:41]
3804 | | | | | `--EXPR -> EXPR [399:41]
3805 | | | | | `--STRING_LITERAL -> "InputIndentationCorrectIfAndParameter.java" [399:41]
3806 | | | | `--RPAREN -> ) [399:85]
3807 | | | |--COMMA -> , [399:86]
3808 | | | `--EXPR -> EXPR [399:88]
3809 | | | `--IDENT -> expected [399:88]
3810 | | `--RPAREN -> ) [399:96]
3811 | |--SEMI -> ; [399:97]
3812 | `--RCURLY -> } [400:4]
3813 |--METHOD_DEF -> METHOD_DEF [402:4]
3814 | |--MODIFIERS -> MODIFIERS [402:4]
3815 | | |--ANNOTATION -> ANNOTATION [402:4]
3816 | | | |--AT -> @ [402:4]
3817 | | | `--IDENT -> Test [402:5]
3818 | | `--LITERAL_PUBLIC -> public [403:4]
3819 | |--TYPE -> TYPE [403:11]
3820 | | `--LITERAL_VOID -> void [403:11]
3821 | |--IDENT -> testAnonymousClasses [403:16]
3822 | |--LPAREN -> ( [403:36]
3823 | |--PARAMETERS -> PARAMETERS [403:37]
3824 | |--RPAREN -> ) [403:37]
3825 | |--LITERAL_THROWS -> throws [403:39]
3826 | | `--IDENT -> Exception [403:46]
3827 | `--SLIST -> { [403:56]
3828 | |--VARIABLE_DEF -> VARIABLE_DEF [404:8]
3829 | | |--MODIFIERS -> MODIFIERS [404:8]
3830 | | | `--FINAL -> final [404:8]
3831 | | |--TYPE -> TYPE [404:14]
3832 | | | `--IDENT -> DefaultConfiguration [404:14]
3833 | | |--IDENT -> checkConfig [404:35]
3834 | | `--ASSIGN -> = [404:47]
3835 | | `--EXPR -> EXPR [404:67]
3836 | | `--METHOD_CALL -> ( [404:67]
3837 | | |--IDENT -> createModuleConfig [404:49]
3838 | | |--ELIST -> ELIST [404:84]
3839 | | | `--EXPR -> EXPR [404:84]
3840 | | | `--DOT -> . [404:84]
3841 | | | |--IDENT -> IndentationCheck [404:68]
3842 | | | `--LITERAL_CLASS -> class [404:85]
3843 | | `--RPAREN -> ) [404:90]
3844 | |--SEMI -> ; [404:91]
3845 | |--EXPR -> EXPR [406:32]
3846 | | `--METHOD_CALL -> ( [406:32]
3847 | | |--DOT -> . [406:19]
3848 | | | |--IDENT -> checkConfig [406:8]
3849 | | | `--IDENT -> addAttribute [406:20]
3850 | | |--ELIST -> ELIST [406:33]
3851 | | | |--EXPR -> EXPR [406:33]
3852 | | | | `--STRING_LITERAL -> "arrayInitIndent" [406:33]
3853 | | | |--COMMA -> , [406:50]
3854 | | | `--EXPR -> EXPR [406:52]
3855 | | | `--STRING_LITERAL -> "4" [406:52]
3856 | | `--RPAREN -> ) [406:55]
3857 | |--SEMI -> ; [406:56]
3858 | |--EXPR -> EXPR [407:32]
3859 | | `--METHOD_CALL -> ( [407:32]
3860 | | |--DOT -> . [407:19]
3861 | | | |--IDENT -> checkConfig [407:8]
3862 | | | `--IDENT -> addAttribute [407:20]
3863 | | |--ELIST -> ELIST [407:33]
3864 | | | |--EXPR -> EXPR [407:33]
3865 | | | | `--STRING_LITERAL -> "basicOffset" [407:33]
3866 | | | |--COMMA -> , [407:46]
3867 | | | `--EXPR -> EXPR [407:48]
3868 | | | `--STRING_LITERAL -> "2" [407:48]
3869 | | `--RPAREN -> ) [407:51]
3870 | |--SEMI -> ; [407:52]
3871 | |--EXPR -> EXPR [408:32]
3872 | | `--METHOD_CALL -> ( [408:32]
3873 | | |--DOT -> . [408:19]
3874 | | | |--IDENT -> checkConfig [408:8]
3875 | | | `--IDENT -> addAttribute [408:20]
3876 | | |--ELIST -> ELIST [408:33]
3877 | | | |--EXPR -> EXPR [408:33]
3878 | | | | `--STRING_LITERAL -> "braceAdjustment" [408:33]
3879 | | | |--COMMA -> , [408:50]
3880 | | | `--EXPR -> EXPR [408:52]
3881 | | | `--STRING_LITERAL -> "0" [408:52]
3882 | | `--RPAREN -> ) [408:55]
3883 | |--SEMI -> ; [408:56]
3884 | |--EXPR -> EXPR [409:32]
3885 | | `--METHOD_CALL -> ( [409:32]
3886 | | |--DOT -> . [409:19]
3887 | | | |--IDENT -> checkConfig [409:8]
3888 | | | `--IDENT -> addAttribute [409:20]
3889 | | |--ELIST -> ELIST [409:33]
3890 | | | |--EXPR -> EXPR [409:33]
3891 | | | | `--STRING_LITERAL -> "caseIndent" [409:33]
3892 | | | |--COMMA -> , [409:45]
3893 | | | `--EXPR -> EXPR [409:47]
3894 | | | `--STRING_LITERAL -> "4" [409:47]
3895 | | `--RPAREN -> ) [409:50]
3896 | |--SEMI -> ; [409:51]
3897 | |--EXPR -> EXPR [410:32]
3898 | | `--METHOD_CALL -> ( [410:32]
3899 | | |--DOT -> . [410:19]
3900 | | | |--IDENT -> checkConfig [410:8]
3901 | | | `--IDENT -> addAttribute [410:20]
3902 | | |--ELIST -> ELIST [410:33]
3903 | | | |--EXPR -> EXPR [410:33]
3904 | | | | `--STRING_LITERAL -> "forceStrictCondition" [410:33]
3905 | | | |--COMMA -> , [410:55]
3906 | | | `--EXPR -> EXPR [410:57]
3907 | | | `--STRING_LITERAL -> "false" [410:57]
3908 | | `--RPAREN -> ) [410:64]
3909 | |--SEMI -> ; [410:65]
3910 | |--EXPR -> EXPR [411:32]
3911 | | `--METHOD_CALL -> ( [411:32]
3912 | | |--DOT -> . [411:19]
3913 | | | |--IDENT -> checkConfig [411:8]
3914 | | | `--IDENT -> addAttribute [411:20]
3915 | | |--ELIST -> ELIST [411:33]
3916 | | | |--EXPR -> EXPR [411:33]
3917 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [411:33]
3918 | | | |--COMMA -> , [411:58]
3919 | | | `--EXPR -> EXPR [411:60]
3920 | | | `--STRING_LITERAL -> "4" [411:60]
3921 | | `--RPAREN -> ) [411:63]
3922 | |--SEMI -> ; [411:64]
3923 | |--EXPR -> EXPR [412:32]
3924 | | `--METHOD_CALL -> ( [412:32]
3925 | | |--DOT -> . [412:19]
3926 | | | |--IDENT -> checkConfig [412:8]
3927 | | | `--IDENT -> addAttribute [412:20]
3928 | | |--ELIST -> ELIST [412:33]
3929 | | | |--EXPR -> EXPR [412:33]
3930 | | | | `--STRING_LITERAL -> "tabWidth" [412:33]
3931 | | | |--COMMA -> , [412:43]
3932 | | | `--EXPR -> EXPR [412:45]
3933 | | | `--STRING_LITERAL -> "4" [412:45]
3934 | | `--RPAREN -> ) [412:48]
3935 | |--SEMI -> ; [412:49]
3936 | |--EXPR -> EXPR [413:32]
3937 | | `--METHOD_CALL -> ( [413:32]
3938 | | |--DOT -> . [413:19]
3939 | | | |--IDENT -> checkConfig [413:8]
3940 | | | `--IDENT -> addAttribute [413:20]
3941 | | |--ELIST -> ELIST [413:33]
3942 | | | |--EXPR -> EXPR [413:33]
3943 | | | | `--STRING_LITERAL -> "throwsIndent" [413:33]
3944 | | | |--COMMA -> , [413:47]
3945 | | | `--EXPR -> EXPR [413:49]
3946 | | | `--STRING_LITERAL -> "4" [413:49]
3947 | | `--RPAREN -> ) [413:52]
3948 | |--SEMI -> ; [413:53]
3949 | |--VARIABLE_DEF -> VARIABLE_DEF [414:8]
3950 | | |--MODIFIERS -> MODIFIERS [414:8]
3951 | | | `--FINAL -> final [414:8]
3952 | | |--TYPE -> TYPE [414:20]
3953 | | | `--ARRAY_DECLARATOR -> [ [414:20]
3954 | | | |--IDENT -> String [414:14]
3955 | | | `--RBRACK -> ] [414:21]
3956 | | |--IDENT -> expected [414:23]
3957 | | `--ASSIGN -> = [414:32]
3958 | | `--EXPR -> EXPR [414:44]
3959 | | `--DOT -> . [414:44]
3960 | | |--IDENT -> CommonUtil [414:34]
3961 | | `--IDENT -> EMPTY_STRING_ARRAY [414:45]
3962 | |--SEMI -> ; [414:63]
3963 | |--EXPR -> EXPR [415:19]
3964 | | `--METHOD_CALL -> ( [415:19]
3965 | | |--IDENT -> verifyWarns [415:8]
3966 | | |--ELIST -> ELIST [415:20]
3967 | | | |--EXPR -> EXPR [415:20]
3968 | | | | `--IDENT -> checkConfig [415:20]
3969 | | | |--COMMA -> , [415:31]
3970 | | | |--EXPR -> EXPR [415:40]
3971 | | | | `--METHOD_CALL -> ( [415:40]
3972 | | | | |--IDENT -> getPath [415:33]
3973 | | | | |--ELIST -> ELIST [415:41]
3974 | | | | | `--EXPR -> EXPR [415:41]
3975 | | | | | `--STRING_LITERAL -> "InputIndentationAnonymousClasses.java" [415:41]
3976 | | | | `--RPAREN -> ) [415:80]
3977 | | | |--COMMA -> , [415:81]
3978 | | | `--EXPR -> EXPR [415:83]
3979 | | | `--IDENT -> expected [415:83]
3980 | | `--RPAREN -> ) [415:91]
3981 | |--SEMI -> ; [415:92]
3982 | `--RCURLY -> } [416:4]
3983 |--METHOD_DEF -> METHOD_DEF [418:4]
3984 | |--MODIFIERS -> MODIFIERS [418:4]
3985 | | |--ANNOTATION -> ANNOTATION [418:4]
3986 | | | |--AT -> @ [418:4]
3987 | | | `--IDENT -> Test [418:5]
3988 | | `--LITERAL_PUBLIC -> public [419:4]
3989 | |--TYPE -> TYPE [419:11]
3990 | | `--LITERAL_VOID -> void [419:11]
3991 | |--IDENT -> testArrays [419:16]
3992 | |--LPAREN -> ( [419:26]
3993 | |--PARAMETERS -> PARAMETERS [419:27]
3994 | |--RPAREN -> ) [419:27]
3995 | |--LITERAL_THROWS -> throws [419:29]
3996 | | `--IDENT -> Exception [419:36]
3997 | `--SLIST -> { [419:46]
3998 | |--VARIABLE_DEF -> VARIABLE_DEF [420:8]
3999 | | |--MODIFIERS -> MODIFIERS [420:8]
4000 | | | `--FINAL -> final [420:8]
4001 | | |--TYPE -> TYPE [420:14]
4002 | | | `--IDENT -> DefaultConfiguration [420:14]
4003 | | |--IDENT -> checkConfig [420:35]
4004 | | `--ASSIGN -> = [420:47]
4005 | | `--EXPR -> EXPR [420:67]
4006 | | `--METHOD_CALL -> ( [420:67]
4007 | | |--IDENT -> createModuleConfig [420:49]
4008 | | |--ELIST -> ELIST [420:84]
4009 | | | `--EXPR -> EXPR [420:84]
4010 | | | `--DOT -> . [420:84]
4011 | | | |--IDENT -> IndentationCheck [420:68]
4012 | | | `--LITERAL_CLASS -> class [420:85]
4013 | | `--RPAREN -> ) [420:90]
4014 | |--SEMI -> ; [420:91]
4015 | |--EXPR -> EXPR [422:32]
4016 | | `--METHOD_CALL -> ( [422:32]
4017 | | |--DOT -> . [422:19]
4018 | | | |--IDENT -> checkConfig [422:8]
4019 | | | `--IDENT -> addAttribute [422:20]
4020 | | |--ELIST -> ELIST [422:33]
4021 | | | |--EXPR -> EXPR [422:33]
4022 | | | | `--STRING_LITERAL -> "arrayInitIndent" [422:33]
4023 | | | |--COMMA -> , [422:50]
4024 | | | `--EXPR -> EXPR [422:52]
4025 | | | `--STRING_LITERAL -> "2" [422:52]
4026 | | `--RPAREN -> ) [422:55]
4027 | |--SEMI -> ; [422:56]
4028 | |--EXPR -> EXPR [423:32]
4029 | | `--METHOD_CALL -> ( [423:32]
4030 | | |--DOT -> . [423:19]
4031 | | | |--IDENT -> checkConfig [423:8]
4032 | | | `--IDENT -> addAttribute [423:20]
4033 | | |--ELIST -> ELIST [423:33]
4034 | | | |--EXPR -> EXPR [423:33]
4035 | | | | `--STRING_LITERAL -> "basicOffset" [423:33]
4036 | | | |--COMMA -> , [423:46]
4037 | | | `--EXPR -> EXPR [423:48]
4038 | | | `--STRING_LITERAL -> "2" [423:48]
4039 | | `--RPAREN -> ) [423:51]
4040 | |--SEMI -> ; [423:52]
4041 | |--EXPR -> EXPR [424:32]
4042 | | `--METHOD_CALL -> ( [424:32]
4043 | | |--DOT -> . [424:19]
4044 | | | |--IDENT -> checkConfig [424:8]
4045 | | | `--IDENT -> addAttribute [424:20]
4046 | | |--ELIST -> ELIST [424:33]
4047 | | | |--EXPR -> EXPR [424:33]
4048 | | | | `--STRING_LITERAL -> "braceAdjustment" [424:33]
4049 | | | |--COMMA -> , [424:50]
4050 | | | `--EXPR -> EXPR [424:52]
4051 | | | `--STRING_LITERAL -> "0" [424:52]
4052 | | `--RPAREN -> ) [424:55]
4053 | |--SEMI -> ; [424:56]
4054 | |--EXPR -> EXPR [425:32]
4055 | | `--METHOD_CALL -> ( [425:32]
4056 | | |--DOT -> . [425:19]
4057 | | | |--IDENT -> checkConfig [425:8]
4058 | | | `--IDENT -> addAttribute [425:20]
4059 | | |--ELIST -> ELIST [425:33]
4060 | | | |--EXPR -> EXPR [425:33]
4061 | | | | `--STRING_LITERAL -> "caseIndent" [425:33]
4062 | | | |--COMMA -> , [425:45]
4063 | | | `--EXPR -> EXPR [425:47]
4064 | | | `--STRING_LITERAL -> "4" [425:47]
4065 | | `--RPAREN -> ) [425:50]
4066 | |--SEMI -> ; [425:51]
4067 | |--EXPR -> EXPR [426:32]
4068 | | `--METHOD_CALL -> ( [426:32]
4069 | | |--DOT -> . [426:19]
4070 | | | |--IDENT -> checkConfig [426:8]
4071 | | | `--IDENT -> addAttribute [426:20]
4072 | | |--ELIST -> ELIST [426:33]
4073 | | | |--EXPR -> EXPR [426:33]
4074 | | | | `--STRING_LITERAL -> "forceStrictCondition" [426:33]
4075 | | | |--COMMA -> , [426:55]
4076 | | | `--EXPR -> EXPR [426:57]
4077 | | | `--STRING_LITERAL -> "false" [426:57]
4078 | | `--RPAREN -> ) [426:64]
4079 | |--SEMI -> ; [426:65]
4080 | |--EXPR -> EXPR [427:32]
4081 | | `--METHOD_CALL -> ( [427:32]
4082 | | |--DOT -> . [427:19]
4083 | | | |--IDENT -> checkConfig [427:8]
4084 | | | `--IDENT -> addAttribute [427:20]
4085 | | |--ELIST -> ELIST [427:33]
4086 | | | |--EXPR -> EXPR [427:33]
4087 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [427:33]
4088 | | | |--COMMA -> , [427:58]
4089 | | | `--EXPR -> EXPR [427:60]
4090 | | | `--STRING_LITERAL -> "4" [427:60]
4091 | | `--RPAREN -> ) [427:63]
4092 | |--SEMI -> ; [427:64]
4093 | |--EXPR -> EXPR [428:32]
4094 | | `--METHOD_CALL -> ( [428:32]
4095 | | |--DOT -> . [428:19]
4096 | | | |--IDENT -> checkConfig [428:8]
4097 | | | `--IDENT -> addAttribute [428:20]
4098 | | |--ELIST -> ELIST [428:33]
4099 | | | |--EXPR -> EXPR [428:33]
4100 | | | | `--STRING_LITERAL -> "tabWidth" [428:33]
4101 | | | |--COMMA -> , [428:43]
4102 | | | `--EXPR -> EXPR [428:45]
4103 | | | `--STRING_LITERAL -> "4" [428:45]
4104 | | `--RPAREN -> ) [428:48]
4105 | |--SEMI -> ; [428:49]
4106 | |--EXPR -> EXPR [429:32]
4107 | | `--METHOD_CALL -> ( [429:32]
4108 | | |--DOT -> . [429:19]
4109 | | | |--IDENT -> checkConfig [429:8]
4110 | | | `--IDENT -> addAttribute [429:20]
4111 | | |--ELIST -> ELIST [429:33]
4112 | | | |--EXPR -> EXPR [429:33]
4113 | | | | `--STRING_LITERAL -> "throwsIndent" [429:33]
4114 | | | |--COMMA -> , [429:47]
4115 | | | `--EXPR -> EXPR [429:49]
4116 | | | `--STRING_LITERAL -> "4" [429:49]
4117 | | `--RPAREN -> ) [429:52]
4118 | |--SEMI -> ; [429:53]
4119 | |--VARIABLE_DEF -> VARIABLE_DEF [430:8]
4120 | | |--MODIFIERS -> MODIFIERS [430:8]
4121 | | | `--FINAL -> final [430:8]
4122 | | |--TYPE -> TYPE [430:20]
4123 | | | `--ARRAY_DECLARATOR -> [ [430:20]
4124 | | | |--IDENT -> String [430:14]
4125 | | | `--RBRACK -> ] [430:21]
4126 | | |--IDENT -> expected [430:23]
4127 | | `--ASSIGN -> = [430:32]
4128 | | `--EXPR -> EXPR [430:44]
4129 | | `--DOT -> . [430:44]
4130 | | |--IDENT -> CommonUtil [430:34]
4131 | | `--IDENT -> EMPTY_STRING_ARRAY [430:45]
4132 | |--SEMI -> ; [430:63]
4133 | |--EXPR -> EXPR [431:19]
4134 | | `--METHOD_CALL -> ( [431:19]
4135 | | |--IDENT -> verifyWarns [431:8]
4136 | | |--ELIST -> ELIST [431:20]
4137 | | | |--EXPR -> EXPR [431:20]
4138 | | | | `--IDENT -> checkConfig [431:20]
4139 | | | |--COMMA -> , [431:31]
4140 | | | |--EXPR -> EXPR [431:40]
4141 | | | | `--METHOD_CALL -> ( [431:40]
4142 | | | | |--IDENT -> getPath [431:33]
4143 | | | | |--ELIST -> ELIST [431:41]
4144 | | | | | `--EXPR -> EXPR [431:41]
4145 | | | | | `--STRING_LITERAL -> "InputIndentationArrays.java" [431:41]
4146 | | | | `--RPAREN -> ) [431:70]
4147 | | | |--COMMA -> , [431:71]
4148 | | | `--EXPR -> EXPR [431:73]
4149 | | | `--IDENT -> expected [431:73]
4150 | | `--RPAREN -> ) [431:81]
4151 | |--SEMI -> ; [431:82]
4152 | `--RCURLY -> } [432:4]
4153 |--METHOD_DEF -> METHOD_DEF [434:4]
4154 | |--MODIFIERS -> MODIFIERS [434:4]
4155 | | |--ANNOTATION -> ANNOTATION [434:4]
4156 | | | |--AT -> @ [434:4]
4157 | | | `--IDENT -> Test [434:5]
4158 | | `--LITERAL_PUBLIC -> public [435:4]
4159 | |--TYPE -> TYPE [435:11]
4160 | | `--LITERAL_VOID -> void [435:11]
4161 | |--IDENT -> testLabels [435:16]
4162 | |--LPAREN -> ( [435:26]
4163 | |--PARAMETERS -> PARAMETERS [435:27]
4164 | |--RPAREN -> ) [435:27]
4165 | |--LITERAL_THROWS -> throws [435:29]
4166 | | `--IDENT -> Exception [435:36]
4167 | `--SLIST -> { [435:46]
4168 | |--VARIABLE_DEF -> VARIABLE_DEF [436:8]
4169 | | |--MODIFIERS -> MODIFIERS [436:8]
4170 | | | `--FINAL -> final [436:8]
4171 | | |--TYPE -> TYPE [436:14]
4172 | | | `--IDENT -> DefaultConfiguration [436:14]
4173 | | |--IDENT -> checkConfig [436:35]
4174 | | `--ASSIGN -> = [436:47]
4175 | | `--EXPR -> EXPR [436:67]
4176 | | `--METHOD_CALL -> ( [436:67]
4177 | | |--IDENT -> createModuleConfig [436:49]
4178 | | |--ELIST -> ELIST [436:84]
4179 | | | `--EXPR -> EXPR [436:84]
4180 | | | `--DOT -> . [436:84]
4181 | | | |--IDENT -> IndentationCheck [436:68]
4182 | | | `--LITERAL_CLASS -> class [436:85]
4183 | | `--RPAREN -> ) [436:90]
4184 | |--SEMI -> ; [436:91]
4185 | |--EXPR -> EXPR [438:32]
4186 | | `--METHOD_CALL -> ( [438:32]
4187 | | |--DOT -> . [438:19]
4188 | | | |--IDENT -> checkConfig [438:8]
4189 | | | `--IDENT -> addAttribute [438:20]
4190 | | |--ELIST -> ELIST [438:33]
4191 | | | |--EXPR -> EXPR [438:33]
4192 | | | | `--STRING_LITERAL -> "arrayInitIndent" [438:33]
4193 | | | |--COMMA -> , [438:50]
4194 | | | `--EXPR -> EXPR [438:52]
4195 | | | `--STRING_LITERAL -> "4" [438:52]
4196 | | `--RPAREN -> ) [438:55]
4197 | |--SEMI -> ; [438:56]
4198 | |--EXPR -> EXPR [439:32]
4199 | | `--METHOD_CALL -> ( [439:32]
4200 | | |--DOT -> . [439:19]
4201 | | | |--IDENT -> checkConfig [439:8]
4202 | | | `--IDENT -> addAttribute [439:20]
4203 | | |--ELIST -> ELIST [439:33]
4204 | | | |--EXPR -> EXPR [439:33]
4205 | | | | `--STRING_LITERAL -> "basicOffset" [439:33]
4206 | | | |--COMMA -> , [439:46]
4207 | | | `--EXPR -> EXPR [439:48]
4208 | | | `--STRING_LITERAL -> "2" [439:48]
4209 | | `--RPAREN -> ) [439:51]
4210 | |--SEMI -> ; [439:52]
4211 | |--EXPR -> EXPR [440:32]
4212 | | `--METHOD_CALL -> ( [440:32]
4213 | | |--DOT -> . [440:19]
4214 | | | |--IDENT -> checkConfig [440:8]
4215 | | | `--IDENT -> addAttribute [440:20]
4216 | | |--ELIST -> ELIST [440:33]
4217 | | | |--EXPR -> EXPR [440:33]
4218 | | | | `--STRING_LITERAL -> "braceAdjustment" [440:33]
4219 | | | |--COMMA -> , [440:50]
4220 | | | `--EXPR -> EXPR [440:52]
4221 | | | `--STRING_LITERAL -> "0" [440:52]
4222 | | `--RPAREN -> ) [440:55]
4223 | |--SEMI -> ; [440:56]
4224 | |--EXPR -> EXPR [441:32]
4225 | | `--METHOD_CALL -> ( [441:32]
4226 | | |--DOT -> . [441:19]
4227 | | | |--IDENT -> checkConfig [441:8]
4228 | | | `--IDENT -> addAttribute [441:20]
4229 | | |--ELIST -> ELIST [441:33]
4230 | | | |--EXPR -> EXPR [441:33]
4231 | | | | `--STRING_LITERAL -> "caseIndent" [441:33]
4232 | | | |--COMMA -> , [441:45]
4233 | | | `--EXPR -> EXPR [441:47]
4234 | | | `--STRING_LITERAL -> "4" [441:47]
4235 | | `--RPAREN -> ) [441:50]
4236 | |--SEMI -> ; [441:51]
4237 | |--EXPR -> EXPR [442:32]
4238 | | `--METHOD_CALL -> ( [442:32]
4239 | | |--DOT -> . [442:19]
4240 | | | |--IDENT -> checkConfig [442:8]
4241 | | | `--IDENT -> addAttribute [442:20]
4242 | | |--ELIST -> ELIST [442:33]
4243 | | | |--EXPR -> EXPR [442:33]
4244 | | | | `--STRING_LITERAL -> "forceStrictCondition" [442:33]
4245 | | | |--COMMA -> , [442:55]
4246 | | | `--EXPR -> EXPR [442:57]
4247 | | | `--STRING_LITERAL -> "false" [442:57]
4248 | | `--RPAREN -> ) [442:64]
4249 | |--SEMI -> ; [442:65]
4250 | |--EXPR -> EXPR [443:32]
4251 | | `--METHOD_CALL -> ( [443:32]
4252 | | |--DOT -> . [443:19]
4253 | | | |--IDENT -> checkConfig [443:8]
4254 | | | `--IDENT -> addAttribute [443:20]
4255 | | |--ELIST -> ELIST [443:33]
4256 | | | |--EXPR -> EXPR [443:33]
4257 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [443:33]
4258 | | | |--COMMA -> , [443:58]
4259 | | | `--EXPR -> EXPR [443:60]
4260 | | | `--STRING_LITERAL -> "4" [443:60]
4261 | | `--RPAREN -> ) [443:63]
4262 | |--SEMI -> ; [443:64]
4263 | |--EXPR -> EXPR [444:32]
4264 | | `--METHOD_CALL -> ( [444:32]
4265 | | |--DOT -> . [444:19]
4266 | | | |--IDENT -> checkConfig [444:8]
4267 | | | `--IDENT -> addAttribute [444:20]
4268 | | |--ELIST -> ELIST [444:33]
4269 | | | |--EXPR -> EXPR [444:33]
4270 | | | | `--STRING_LITERAL -> "tabWidth" [444:33]
4271 | | | |--COMMA -> , [444:43]
4272 | | | `--EXPR -> EXPR [444:45]
4273 | | | `--STRING_LITERAL -> "4" [444:45]
4274 | | `--RPAREN -> ) [444:48]
4275 | |--SEMI -> ; [444:49]
4276 | |--EXPR -> EXPR [445:32]
4277 | | `--METHOD_CALL -> ( [445:32]
4278 | | |--DOT -> . [445:19]
4279 | | | |--IDENT -> checkConfig [445:8]
4280 | | | `--IDENT -> addAttribute [445:20]
4281 | | |--ELIST -> ELIST [445:33]
4282 | | | |--EXPR -> EXPR [445:33]
4283 | | | | `--STRING_LITERAL -> "throwsIndent" [445:33]
4284 | | | |--COMMA -> , [445:47]
4285 | | | `--EXPR -> EXPR [445:49]
4286 | | | `--STRING_LITERAL -> "4" [445:49]
4287 | | `--RPAREN -> ) [445:52]
4288 | |--SEMI -> ; [445:53]
4289 | |--VARIABLE_DEF -> VARIABLE_DEF [446:8]
4290 | | |--MODIFIERS -> MODIFIERS [446:8]
4291 | | | `--FINAL -> final [446:8]
4292 | | |--TYPE -> TYPE [446:20]
4293 | | | `--ARRAY_DECLARATOR -> [ [446:20]
4294 | | | |--IDENT -> String [446:14]
4295 | | | `--RBRACK -> ] [446:21]
4296 | | |--IDENT -> expected [446:23]
4297 | | `--ASSIGN -> = [446:32]
4298 | | `--EXPR -> EXPR [446:44]
4299 | | `--DOT -> . [446:44]
4300 | | |--IDENT -> CommonUtil [446:34]
4301 | | `--IDENT -> EMPTY_STRING_ARRAY [446:45]
4302 | |--SEMI -> ; [446:63]
4303 | |--EXPR -> EXPR [447:19]
4304 | | `--METHOD_CALL -> ( [447:19]
4305 | | |--IDENT -> verifyWarns [447:8]
4306 | | |--ELIST -> ELIST [447:20]
4307 | | | |--EXPR -> EXPR [447:20]
4308 | | | | `--IDENT -> checkConfig [447:20]
4309 | | | |--COMMA -> , [447:31]
4310 | | | |--EXPR -> EXPR [447:40]
4311 | | | | `--METHOD_CALL -> ( [447:40]
4312 | | | | |--IDENT -> getPath [447:33]
4313 | | | | |--ELIST -> ELIST [447:41]
4314 | | | | | `--EXPR -> EXPR [447:41]
4315 | | | | | `--STRING_LITERAL -> "InputIndentationLabels.java" [447:41]
4316 | | | | `--RPAREN -> ) [447:70]
4317 | | | |--COMMA -> , [447:71]
4318 | | | `--EXPR -> EXPR [447:73]
4319 | | | `--IDENT -> expected [447:73]
4320 | | `--RPAREN -> ) [447:81]
4321 | |--SEMI -> ; [447:82]
4322 | `--RCURLY -> } [448:4]
4323 |--METHOD_DEF -> METHOD_DEF [450:4]
4324 | |--MODIFIERS -> MODIFIERS [450:4]
4325 | | |--ANNOTATION -> ANNOTATION [450:4]
4326 | | | |--AT -> @ [450:4]
4327 | | | `--IDENT -> Test [450:5]
4328 | | `--LITERAL_PUBLIC -> public [451:4]
4329 | |--TYPE -> TYPE [451:11]
4330 | | `--LITERAL_VOID -> void [451:11]
4331 | |--IDENT -> testClassesAndMethods [451:16]
4332 | |--LPAREN -> ( [451:37]
4333 | |--PARAMETERS -> PARAMETERS [451:38]
4334 | |--RPAREN -> ) [451:38]
4335 | |--LITERAL_THROWS -> throws [451:40]
4336 | | `--IDENT -> Exception [451:47]
4337 | `--SLIST -> { [451:57]
4338 | |--VARIABLE_DEF -> VARIABLE_DEF [452:8]
4339 | | |--MODIFIERS -> MODIFIERS [452:8]
4340 | | | `--FINAL -> final [452:8]
4341 | | |--TYPE -> TYPE [452:14]
4342 | | | `--IDENT -> DefaultConfiguration [452:14]
4343 | | |--IDENT -> checkConfig [452:35]
4344 | | `--ASSIGN -> = [452:47]
4345 | | `--EXPR -> EXPR [452:67]
4346 | | `--METHOD_CALL -> ( [452:67]
4347 | | |--IDENT -> createModuleConfig [452:49]
4348 | | |--ELIST -> ELIST [452:84]
4349 | | | `--EXPR -> EXPR [452:84]
4350 | | | `--DOT -> . [452:84]
4351 | | | |--IDENT -> IndentationCheck [452:68]
4352 | | | `--LITERAL_CLASS -> class [452:85]
4353 | | `--RPAREN -> ) [452:90]
4354 | |--SEMI -> ; [452:91]
4355 | |--EXPR -> EXPR [454:32]
4356 | | `--METHOD_CALL -> ( [454:32]
4357 | | |--DOT -> . [454:19]
4358 | | | |--IDENT -> checkConfig [454:8]
4359 | | | `--IDENT -> addAttribute [454:20]
4360 | | |--ELIST -> ELIST [454:33]
4361 | | | |--EXPR -> EXPR [454:33]
4362 | | | | `--STRING_LITERAL -> "arrayInitIndent" [454:33]
4363 | | | |--COMMA -> , [454:50]
4364 | | | `--EXPR -> EXPR [454:52]
4365 | | | `--STRING_LITERAL -> "4" [454:52]
4366 | | `--RPAREN -> ) [454:55]
4367 | |--SEMI -> ; [454:56]
4368 | |--EXPR -> EXPR [455:32]
4369 | | `--METHOD_CALL -> ( [455:32]
4370 | | |--DOT -> . [455:19]
4371 | | | |--IDENT -> checkConfig [455:8]
4372 | | | `--IDENT -> addAttribute [455:20]
4373 | | |--ELIST -> ELIST [455:33]
4374 | | | |--EXPR -> EXPR [455:33]
4375 | | | | `--STRING_LITERAL -> "basicOffset" [455:33]
4376 | | | |--COMMA -> , [455:46]
4377 | | | `--EXPR -> EXPR [455:48]
4378 | | | `--STRING_LITERAL -> "2" [455:48]
4379 | | `--RPAREN -> ) [455:51]
4380 | |--SEMI -> ; [455:52]
4381 | |--EXPR -> EXPR [456:32]
4382 | | `--METHOD_CALL -> ( [456:32]
4383 | | |--DOT -> . [456:19]
4384 | | | |--IDENT -> checkConfig [456:8]
4385 | | | `--IDENT -> addAttribute [456:20]
4386 | | |--ELIST -> ELIST [456:33]
4387 | | | |--EXPR -> EXPR [456:33]
4388 | | | | `--STRING_LITERAL -> "braceAdjustment" [456:33]
4389 | | | |--COMMA -> , [456:50]
4390 | | | `--EXPR -> EXPR [456:52]
4391 | | | `--STRING_LITERAL -> "0" [456:52]
4392 | | `--RPAREN -> ) [456:55]
4393 | |--SEMI -> ; [456:56]
4394 | |--EXPR -> EXPR [457:32]
4395 | | `--METHOD_CALL -> ( [457:32]
4396 | | |--DOT -> . [457:19]
4397 | | | |--IDENT -> checkConfig [457:8]
4398 | | | `--IDENT -> addAttribute [457:20]
4399 | | |--ELIST -> ELIST [457:33]
4400 | | | |--EXPR -> EXPR [457:33]
4401 | | | | `--STRING_LITERAL -> "caseIndent" [457:33]
4402 | | | |--COMMA -> , [457:45]
4403 | | | `--EXPR -> EXPR [457:47]
4404 | | | `--STRING_LITERAL -> "4" [457:47]
4405 | | `--RPAREN -> ) [457:50]
4406 | |--SEMI -> ; [457:51]
4407 | |--EXPR -> EXPR [458:32]
4408 | | `--METHOD_CALL -> ( [458:32]
4409 | | |--DOT -> . [458:19]
4410 | | | |--IDENT -> checkConfig [458:8]
4411 | | | `--IDENT -> addAttribute [458:20]
4412 | | |--ELIST -> ELIST [458:33]
4413 | | | |--EXPR -> EXPR [458:33]
4414 | | | | `--STRING_LITERAL -> "forceStrictCondition" [458:33]
4415 | | | |--COMMA -> , [458:55]
4416 | | | `--EXPR -> EXPR [458:57]
4417 | | | `--STRING_LITERAL -> "false" [458:57]
4418 | | `--RPAREN -> ) [458:64]
4419 | |--SEMI -> ; [458:65]
4420 | |--EXPR -> EXPR [459:32]
4421 | | `--METHOD_CALL -> ( [459:32]
4422 | | |--DOT -> . [459:19]
4423 | | | |--IDENT -> checkConfig [459:8]
4424 | | | `--IDENT -> addAttribute [459:20]
4425 | | |--ELIST -> ELIST [459:33]
4426 | | | |--EXPR -> EXPR [459:33]
4427 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [459:33]
4428 | | | |--COMMA -> , [459:58]
4429 | | | `--EXPR -> EXPR [459:60]
4430 | | | `--STRING_LITERAL -> "4" [459:60]
4431 | | `--RPAREN -> ) [459:63]
4432 | |--SEMI -> ; [459:64]
4433 | |--EXPR -> EXPR [460:32]
4434 | | `--METHOD_CALL -> ( [460:32]
4435 | | |--DOT -> . [460:19]
4436 | | | |--IDENT -> checkConfig [460:8]
4437 | | | `--IDENT -> addAttribute [460:20]
4438 | | |--ELIST -> ELIST [460:33]
4439 | | | |--EXPR -> EXPR [460:33]
4440 | | | | `--STRING_LITERAL -> "tabWidth" [460:33]
4441 | | | |--COMMA -> , [460:43]
4442 | | | `--EXPR -> EXPR [460:45]
4443 | | | `--STRING_LITERAL -> "4" [460:45]
4444 | | `--RPAREN -> ) [460:48]
4445 | |--SEMI -> ; [460:49]
4446 | |--EXPR -> EXPR [461:32]
4447 | | `--METHOD_CALL -> ( [461:32]
4448 | | |--DOT -> . [461:19]
4449 | | | |--IDENT -> checkConfig [461:8]
4450 | | | `--IDENT -> addAttribute [461:20]
4451 | | |--ELIST -> ELIST [461:33]
4452 | | | |--EXPR -> EXPR [461:33]
4453 | | | | `--STRING_LITERAL -> "throwsIndent" [461:33]
4454 | | | |--COMMA -> , [461:47]
4455 | | | `--EXPR -> EXPR [461:49]
4456 | | | `--STRING_LITERAL -> "4" [461:49]
4457 | | `--RPAREN -> ) [461:52]
4458 | |--SEMI -> ; [461:53]
4459 | |--VARIABLE_DEF -> VARIABLE_DEF [462:8]
4460 | | |--MODIFIERS -> MODIFIERS [462:8]
4461 | | | `--FINAL -> final [462:8]
4462 | | |--TYPE -> TYPE [462:20]
4463 | | | `--ARRAY_DECLARATOR -> [ [462:20]
4464 | | | |--IDENT -> String [462:14]
4465 | | | `--RBRACK -> ] [462:21]
4466 | | |--IDENT -> expected [462:23]
4467 | | `--ASSIGN -> = [462:32]
4468 | | `--EXPR -> EXPR [462:44]
4469 | | `--DOT -> . [462:44]
4470 | | |--IDENT -> CommonUtil [462:34]
4471 | | `--IDENT -> EMPTY_STRING_ARRAY [462:45]
4472 | |--SEMI -> ; [462:63]
4473 | |--EXPR -> EXPR [463:19]
4474 | | `--METHOD_CALL -> ( [463:19]
4475 | | |--IDENT -> verifyWarns [463:8]
4476 | | |--ELIST -> ELIST [463:20]
4477 | | | |--EXPR -> EXPR [463:20]
4478 | | | | `--IDENT -> checkConfig [463:20]
4479 | | | |--COMMA -> , [463:31]
4480 | | | |--EXPR -> EXPR [463:40]
4481 | | | | `--METHOD_CALL -> ( [463:40]
4482 | | | | |--IDENT -> getPath [463:33]
4483 | | | | |--ELIST -> ELIST [463:41]
4484 | | | | | `--EXPR -> EXPR [463:41]
4485 | | | | | `--STRING_LITERAL -> "InputIndentationClassesMethods.java" [463:41]
4486 | | | | `--RPAREN -> ) [463:78]
4487 | | | |--COMMA -> , [463:79]
4488 | | | `--EXPR -> EXPR [463:81]
4489 | | | `--IDENT -> expected [463:81]
4490 | | `--RPAREN -> ) [463:89]
4491 | |--SEMI -> ; [463:90]
4492 | `--RCURLY -> } [464:4]
4493 |--METHOD_DEF -> METHOD_DEF [466:4]
4494 | |--MODIFIERS -> MODIFIERS [466:4]
4495 | | |--ANNOTATION -> ANNOTATION [466:4]
4496 | | | |--AT -> @ [466:4]
4497 | | | `--IDENT -> Test [466:5]
4498 | | `--LITERAL_PUBLIC -> public [467:4]
4499 | |--TYPE -> TYPE [467:11]
4500 | | `--LITERAL_VOID -> void [467:11]
4501 | |--IDENT -> testCtorCall [467:16]
4502 | |--LPAREN -> ( [467:28]
4503 | |--PARAMETERS -> PARAMETERS [467:29]
4504 | |--RPAREN -> ) [467:29]
4505 | |--LITERAL_THROWS -> throws [467:31]
4506 | | `--IDENT -> Exception [467:38]
4507 | `--SLIST -> { [467:48]
4508 | |--VARIABLE_DEF -> VARIABLE_DEF [468:8]
4509 | | |--MODIFIERS -> MODIFIERS [468:8]
4510 | | | `--FINAL -> final [468:8]
4511 | | |--TYPE -> TYPE [468:14]
4512 | | | `--IDENT -> DefaultConfiguration [468:14]
4513 | | |--IDENT -> checkConfig [468:35]
4514 | | `--ASSIGN -> = [468:47]
4515 | | `--EXPR -> EXPR [468:67]
4516 | | `--METHOD_CALL -> ( [468:67]
4517 | | |--IDENT -> createModuleConfig [468:49]
4518 | | |--ELIST -> ELIST [468:84]
4519 | | | `--EXPR -> EXPR [468:84]
4520 | | | `--DOT -> . [468:84]
4521 | | | |--IDENT -> IndentationCheck [468:68]
4522 | | | `--LITERAL_CLASS -> class [468:85]
4523 | | `--RPAREN -> ) [468:90]
4524 | |--SEMI -> ; [468:91]
4525 | |--EXPR -> EXPR [470:32]
4526 | | `--METHOD_CALL -> ( [470:32]
4527 | | |--DOT -> . [470:19]
4528 | | | |--IDENT -> checkConfig [470:8]
4529 | | | `--IDENT -> addAttribute [470:20]
4530 | | |--ELIST -> ELIST [470:33]
4531 | | | |--EXPR -> EXPR [470:33]
4532 | | | | `--STRING_LITERAL -> "basicOffset" [470:33]
4533 | | | |--COMMA -> , [470:46]
4534 | | | `--EXPR -> EXPR [470:48]
4535 | | | `--STRING_LITERAL -> "2" [470:48]
4536 | | `--RPAREN -> ) [470:51]
4537 | |--SEMI -> ; [470:52]
4538 | |--EXPR -> EXPR [471:32]
4539 | | `--METHOD_CALL -> ( [471:32]
4540 | | |--DOT -> . [471:19]
4541 | | | |--IDENT -> checkConfig [471:8]
4542 | | | `--IDENT -> addAttribute [471:20]
4543 | | |--ELIST -> ELIST [471:33]
4544 | | | |--EXPR -> EXPR [471:33]
4545 | | | | `--STRING_LITERAL -> "braceAdjustment" [471:33]
4546 | | | |--COMMA -> , [471:50]
4547 | | | `--EXPR -> EXPR [471:52]
4548 | | | `--STRING_LITERAL -> "0" [471:52]
4549 | | `--RPAREN -> ) [471:55]
4550 | |--SEMI -> ; [471:56]
4551 | |--EXPR -> EXPR [472:32]
4552 | | `--METHOD_CALL -> ( [472:32]
4553 | | |--DOT -> . [472:19]
4554 | | | |--IDENT -> checkConfig [472:8]
4555 | | | `--IDENT -> addAttribute [472:20]
4556 | | |--ELIST -> ELIST [472:33]
4557 | | | |--EXPR -> EXPR [472:33]
4558 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [472:33]
4559 | | | |--COMMA -> , [472:58]
4560 | | | `--EXPR -> EXPR [472:60]
4561 | | | `--STRING_LITERAL -> "4" [472:60]
4562 | | `--RPAREN -> ) [472:63]
4563 | |--SEMI -> ; [472:64]
4564 | |--EXPR -> EXPR [473:32]
4565 | | `--METHOD_CALL -> ( [473:32]
4566 | | |--DOT -> . [473:19]
4567 | | | |--IDENT -> checkConfig [473:8]
4568 | | | `--IDENT -> addAttribute [473:20]
4569 | | |--ELIST -> ELIST [473:33]
4570 | | | |--EXPR -> EXPR [473:33]
4571 | | | | `--STRING_LITERAL -> "tabWidth" [473:33]
4572 | | | |--COMMA -> , [473:43]
4573 | | | `--EXPR -> EXPR [473:45]
4574 | | | `--STRING_LITERAL -> "4" [473:45]
4575 | | `--RPAREN -> ) [473:48]
4576 | |--SEMI -> ; [473:49]
4577 | |--VARIABLE_DEF -> VARIABLE_DEF [474:8]
4578 | | |--MODIFIERS -> MODIFIERS [474:8]
4579 | | | `--FINAL -> final [474:8]
4580 | | |--TYPE -> TYPE [474:20]
4581 | | | `--ARRAY_DECLARATOR -> [ [474:20]
4582 | | | |--IDENT -> String [474:14]
4583 | | | `--RBRACK -> ] [474:21]
4584 | | |--IDENT -> expected [474:23]
4585 | | `--ASSIGN -> = [474:32]
4586 | | `--ARRAY_INIT -> { [474:34]
4587 | | |--EXPR -> EXPR [475:21]
4588 | | | `--PLUS -> + [475:21]
4589 | | | |--STRING_LITERAL -> "28:5: " [475:12]
4590 | | | `--METHOD_CALL -> ( [475:38]
4591 | | | |--IDENT -> getCheckMessage [475:23]
4592 | | | |--ELIST -> ELIST [475:39]
4593 | | | | |--EXPR -> EXPR [475:39]
4594 | | | | | `--IDENT -> MSG_CHILD_ERROR [475:39]
4595 | | | | |--COMMA -> , [475:54]
4596 | | | | |--EXPR -> EXPR [475:56]
4597 | | | | | `--STRING_LITERAL -> "ctor def" [475:56]
4598 | | | | |--COMMA -> , [475:66]
4599 | | | | |--EXPR -> EXPR [475:68]
4600 | | | | | `--NUM_INT -> 4 [475:68]
4601 | | | | |--COMMA -> , [475:69]
4602 | | | | `--EXPR -> EXPR [475:71]
4603 | | | | `--NUM_INT -> 6 [475:71]
4604 | | | `--RPAREN -> ) [475:72]
4605 | | |--COMMA -> , [475:73]
4606 | | |--EXPR -> EXPR [476:21]
4607 | | | `--PLUS -> + [476:21]
4608 | | | |--STRING_LITERAL -> "29:5: " [476:12]
4609 | | | `--METHOD_CALL -> ( [476:38]
4610 | | | |--IDENT -> getCheckMessage [476:23]
4611 | | | |--ELIST -> ELIST [476:39]
4612 | | | | |--EXPR -> EXPR [476:39]
4613 | | | | | `--IDENT -> MSG_CHILD_ERROR [476:39]
4614 | | | | |--COMMA -> , [476:54]
4615 | | | | |--EXPR -> EXPR [476:56]
4616 | | | | | `--STRING_LITERAL -> "method call" [476:56]
4617 | | | | |--COMMA -> , [476:69]
4618 | | | | |--EXPR -> EXPR [476:71]
4619 | | | | | `--NUM_INT -> 4 [476:71]
4620 | | | | |--COMMA -> , [476:72]
4621 | | | | `--EXPR -> EXPR [476:74]
4622 | | | | `--NUM_INT -> 6 [476:74]
4623 | | | `--RPAREN -> ) [476:75]
4624 | | |--COMMA -> , [476:76]
4625 | | |--EXPR -> EXPR [477:21]
4626 | | | `--PLUS -> + [477:21]
4627 | | | |--STRING_LITERAL -> "30:5: " [477:12]
4628 | | | `--METHOD_CALL -> ( [477:38]
4629 | | | |--IDENT -> getCheckMessage [477:23]
4630 | | | |--ELIST -> ELIST [477:39]
4631 | | | | |--EXPR -> EXPR [477:39]
4632 | | | | | `--IDENT -> MSG_CHILD_ERROR [477:39]
4633 | | | | |--COMMA -> , [477:54]
4634 | | | | |--EXPR -> EXPR [477:56]
4635 | | | | | `--STRING_LITERAL -> "method call" [477:56]
4636 | | | | |--COMMA -> , [477:69]
4637 | | | | |--EXPR -> EXPR [477:71]
4638 | | | | | `--NUM_INT -> 4 [477:71]
4639 | | | | |--COMMA -> , [477:72]
4640 | | | | `--EXPR -> EXPR [477:74]
4641 | | | | `--NUM_INT -> 6 [477:74]
4642 | | | `--RPAREN -> ) [477:75]
4643 | | |--COMMA -> , [477:76]
4644 | | |--EXPR -> EXPR [478:21]
4645 | | | `--PLUS -> + [478:21]
4646 | | | |--STRING_LITERAL -> "34:5: " [478:12]
4647 | | | `--METHOD_CALL -> ( [478:38]
4648 | | | |--IDENT -> getCheckMessage [478:23]
4649 | | | |--ELIST -> ELIST [478:39]
4650 | | | | |--EXPR -> EXPR [478:39]
4651 | | | | | `--IDENT -> MSG_CHILD_ERROR [478:39]
4652 | | | | |--COMMA -> , [478:54]
4653 | | | | |--EXPR -> EXPR [478:56]
4654 | | | | | `--STRING_LITERAL -> "ctor def" [478:56]
4655 | | | | |--COMMA -> , [478:66]
4656 | | | | |--EXPR -> EXPR [478:68]
4657 | | | | | `--NUM_INT -> 4 [478:68]
4658 | | | | |--COMMA -> , [478:69]
4659 | | | | `--EXPR -> EXPR [478:71]
4660 | | | | `--NUM_INT -> 6 [478:71]
4661 | | | `--RPAREN -> ) [478:72]
4662 | | |--COMMA -> , [478:73]
4663 | | |--EXPR -> EXPR [479:21]
4664 | | | `--PLUS -> + [479:21]
4665 | | | |--STRING_LITERAL -> "35:5: " [479:12]
4666 | | | `--METHOD_CALL -> ( [479:38]
4667 | | | |--IDENT -> getCheckMessage [479:23]
4668 | | | |--ELIST -> ELIST [479:39]
4669 | | | | |--EXPR -> EXPR [479:39]
4670 | | | | | `--IDENT -> MSG_CHILD_ERROR [479:39]
4671 | | | | |--COMMA -> , [479:54]
4672 | | | | |--EXPR -> EXPR [479:56]
4673 | | | | | `--STRING_LITERAL -> "method call" [479:56]
4674 | | | | |--COMMA -> , [479:69]
4675 | | | | |--EXPR -> EXPR [479:71]
4676 | | | | | `--NUM_INT -> 4 [479:71]
4677 | | | | |--COMMA -> , [479:72]
4678 | | | | `--EXPR -> EXPR [479:74]
4679 | | | | `--NUM_INT -> 6 [479:74]
4680 | | | `--RPAREN -> ) [479:75]
4681 | | |--COMMA -> , [479:76]
4682 | | |--EXPR -> EXPR [480:21]
4683 | | | `--PLUS -> + [480:21]
4684 | | | |--STRING_LITERAL -> "39:5: " [480:12]
4685 | | | `--METHOD_CALL -> ( [480:38]
4686 | | | |--IDENT -> getCheckMessage [480:23]
4687 | | | |--ELIST -> ELIST [480:39]
4688 | | | | |--EXPR -> EXPR [480:39]
4689 | | | | | `--IDENT -> MSG_CHILD_ERROR [480:39]
4690 | | | | |--COMMA -> , [480:54]
4691 | | | | |--EXPR -> EXPR [480:56]
4692 | | | | | `--STRING_LITERAL -> "ctor def" [480:56]
4693 | | | | |--COMMA -> , [480:66]
4694 | | | | |--EXPR -> EXPR [480:68]
4695 | | | | | `--NUM_INT -> 4 [480:68]
4696 | | | | |--COMMA -> , [480:69]
4697 | | | | `--EXPR -> EXPR [480:71]
4698 | | | | `--NUM_INT -> 6 [480:71]
4699 | | | `--RPAREN -> ) [480:72]
4700 | | |--COMMA -> , [480:73]
4701 | | |--EXPR -> EXPR [481:21]
4702 | | | `--PLUS -> + [481:21]
4703 | | | |--STRING_LITERAL -> "40:5: " [481:12]
4704 | | | `--METHOD_CALL -> ( [481:38]
4705 | | | |--IDENT -> getCheckMessage [481:23]
4706 | | | |--ELIST -> ELIST [481:39]
4707 | | | | |--EXPR -> EXPR [481:39]
4708 | | | | | `--IDENT -> MSG_CHILD_ERROR [481:39]
4709 | | | | |--COMMA -> , [481:54]
4710 | | | | |--EXPR -> EXPR [481:56]
4711 | | | | | `--STRING_LITERAL -> "method call" [481:56]
4712 | | | | |--COMMA -> , [481:69]
4713 | | | | |--EXPR -> EXPR [481:71]
4714 | | | | | `--NUM_INT -> 4 [481:71]
4715 | | | | |--COMMA -> , [481:72]
4716 | | | | `--EXPR -> EXPR [481:74]
4717 | | | | `--NUM_INT -> 8 [481:74]
4718 | | | `--RPAREN -> ) [481:75]
4719 | | |--COMMA -> , [481:76]
4720 | | |--EXPR -> EXPR [482:21]
4721 | | | `--PLUS -> + [482:21]
4722 | | | |--STRING_LITERAL -> "41:5: " [482:12]
4723 | | | `--METHOD_CALL -> ( [482:38]
4724 | | | |--IDENT -> getCheckMessage [482:23]
4725 | | | |--ELIST -> ELIST [482:39]
4726 | | | | |--EXPR -> EXPR [482:39]
4727 | | | | | `--IDENT -> MSG_CHILD_ERROR [482:39]
4728 | | | | |--COMMA -> , [482:54]
4729 | | | | |--EXPR -> EXPR [482:56]
4730 | | | | | `--STRING_LITERAL -> "method call" [482:56]
4731 | | | | |--COMMA -> , [482:69]
4732 | | | | |--EXPR -> EXPR [482:71]
4733 | | | | | `--NUM_INT -> 4 [482:71]
4734 | | | | |--COMMA -> , [482:72]
4735 | | | | `--EXPR -> EXPR [482:74]
4736 | | | | `--NUM_INT -> 8 [482:74]
4737 | | | `--RPAREN -> ) [482:75]
4738 | | |--COMMA -> , [482:76]
4739 | | |--EXPR -> EXPR [483:21]
4740 | | | `--PLUS -> + [483:21]
4741 | | | |--STRING_LITERAL -> "45:5: " [483:12]
4742 | | | `--METHOD_CALL -> ( [483:38]
4743 | | | |--IDENT -> getCheckMessage [483:23]
4744 | | | |--ELIST -> ELIST [483:39]
4745 | | | | |--EXPR -> EXPR [483:39]
4746 | | | | | `--IDENT -> MSG_CHILD_ERROR [483:39]
4747 | | | | |--COMMA -> , [483:54]
4748 | | | | |--EXPR -> EXPR [483:56]
4749 | | | | | `--STRING_LITERAL -> "ctor def" [483:56]
4750 | | | | |--COMMA -> , [483:66]
4751 | | | | |--EXPR -> EXPR [483:68]
4752 | | | | | `--NUM_INT -> 4 [483:68]
4753 | | | | |--COMMA -> , [483:69]
4754 | | | | `--EXPR -> EXPR [483:71]
4755 | | | | `--NUM_INT -> 6 [483:71]
4756 | | | `--RPAREN -> ) [483:72]
4757 | | |--COMMA -> , [483:73]
4758 | | |--EXPR -> EXPR [484:21]
4759 | | | `--PLUS -> + [484:21]
4760 | | | |--STRING_LITERAL -> "46:5: " [484:12]
4761 | | | `--METHOD_CALL -> ( [484:38]
4762 | | | |--IDENT -> getCheckMessage [484:23]
4763 | | | |--ELIST -> ELIST [484:39]
4764 | | | | |--EXPR -> EXPR [484:39]
4765 | | | | | `--IDENT -> MSG_CHILD_ERROR [484:39]
4766 | | | | |--COMMA -> , [484:54]
4767 | | | | |--EXPR -> EXPR [484:56]
4768 | | | | | `--STRING_LITERAL -> "method call" [484:56]
4769 | | | | |--COMMA -> , [484:69]
4770 | | | | |--EXPR -> EXPR [484:71]
4771 | | | | | `--NUM_INT -> 4 [484:71]
4772 | | | | |--COMMA -> , [484:72]
4773 | | | | `--EXPR -> EXPR [484:74]
4774 | | | | `--NUM_INT -> 8 [484:74]
4775 | | | `--RPAREN -> ) [484:75]
4776 | | |--COMMA -> , [484:76]
4777 | | |--EXPR -> EXPR [485:21]
4778 | | | `--PLUS -> + [485:21]
4779 | | | |--STRING_LITERAL -> "50:5: " [485:12]
4780 | | | `--METHOD_CALL -> ( [485:38]
4781 | | | |--IDENT -> getCheckMessage [485:23]
4782 | | | |--ELIST -> ELIST [485:39]
4783 | | | | |--EXPR -> EXPR [485:39]
4784 | | | | | `--IDENT -> MSG_CHILD_ERROR [485:39]
4785 | | | | |--COMMA -> , [485:54]
4786 | | | | |--EXPR -> EXPR [485:56]
4787 | | | | | `--STRING_LITERAL -> "ctor def" [485:56]
4788 | | | | |--COMMA -> , [485:66]
4789 | | | | |--EXPR -> EXPR [485:68]
4790 | | | | | `--NUM_INT -> 4 [485:68]
4791 | | | | |--COMMA -> , [485:69]
4792 | | | | `--EXPR -> EXPR [485:71]
4793 | | | | `--NUM_INT -> 6 [485:71]
4794 | | | `--RPAREN -> ) [485:72]
4795 | | |--COMMA -> , [485:73]
4796 | | |--EXPR -> EXPR [486:21]
4797 | | | `--PLUS -> + [486:21]
4798 | | | |--STRING_LITERAL -> "51:5: " [486:12]
4799 | | | `--METHOD_CALL -> ( [486:38]
4800 | | | |--IDENT -> getCheckMessage [486:23]
4801 | | | |--ELIST -> ELIST [486:39]
4802 | | | | |--EXPR -> EXPR [486:39]
4803 | | | | | `--IDENT -> MSG_ERROR [486:39]
4804 | | | | |--COMMA -> , [486:48]
4805 | | | | |--EXPR -> EXPR [486:50]
4806 | | | | | `--STRING_LITERAL -> "(" [486:50]
4807 | | | | |--COMMA -> , [486:53]
4808 | | | | |--EXPR -> EXPR [486:55]
4809 | | | | | `--NUM_INT -> 4 [486:55]
4810 | | | | |--COMMA -> , [486:56]
4811 | | | | `--EXPR -> EXPR [486:58]
4812 | | | | `--NUM_INT -> 8 [486:58]
4813 | | | `--RPAREN -> ) [486:59]
4814 | | |--COMMA -> , [486:60]
4815 | | |--EXPR -> EXPR [487:21]
4816 | | | `--PLUS -> + [487:21]
4817 | | | |--STRING_LITERAL -> "52:5: " [487:12]
4818 | | | `--METHOD_CALL -> ( [487:38]
4819 | | | |--IDENT -> getCheckMessage [487:23]
4820 | | | |--ELIST -> ELIST [487:39]
4821 | | | | |--EXPR -> EXPR [487:39]
4822 | | | | | `--IDENT -> MSG_ERROR [487:39]
4823 | | | | |--COMMA -> , [487:48]
4824 | | | | |--EXPR -> EXPR [487:50]
4825 | | | | | `--STRING_LITERAL -> "x" [487:50]
4826 | | | | |--COMMA -> , [487:53]
4827 | | | | |--EXPR -> EXPR [487:55]
4828 | | | | | `--NUM_INT -> 4 [487:55]
4829 | | | | |--COMMA -> , [487:56]
4830 | | | | `--EXPR -> EXPR [487:58]
4831 | | | | `--NUM_INT -> 8 [487:58]
4832 | | | `--RPAREN -> ) [487:59]
4833 | | |--COMMA -> , [487:60]
4834 | | |--EXPR -> EXPR [488:21]
4835 | | | `--PLUS -> + [488:21]
4836 | | | |--STRING_LITERAL -> "56:5: " [488:12]
4837 | | | `--METHOD_CALL -> ( [488:38]
4838 | | | |--IDENT -> getCheckMessage [488:23]
4839 | | | |--ELIST -> ELIST [488:39]
4840 | | | | |--EXPR -> EXPR [488:39]
4841 | | | | | `--IDENT -> MSG_CHILD_ERROR [488:39]
4842 | | | | |--COMMA -> , [488:54]
4843 | | | | |--EXPR -> EXPR [488:56]
4844 | | | | | `--STRING_LITERAL -> "ctor def" [488:56]
4845 | | | | |--COMMA -> , [488:66]
4846 | | | | |--EXPR -> EXPR [488:68]
4847 | | | | | `--NUM_INT -> 4 [488:68]
4848 | | | | |--COMMA -> , [488:69]
4849 | | | | `--EXPR -> EXPR [488:71]
4850 | | | | `--NUM_INT -> 6 [488:71]
4851 | | | `--RPAREN -> ) [488:72]
4852 | | |--COMMA -> , [488:73]
4853 | | |--EXPR -> EXPR [489:21]
4854 | | | `--PLUS -> + [489:21]
4855 | | | |--STRING_LITERAL -> "57:5: " [489:12]
4856 | | | `--METHOD_CALL -> ( [489:38]
4857 | | | |--IDENT -> getCheckMessage [489:23]
4858 | | | |--ELIST -> ELIST [489:39]
4859 | | | | |--EXPR -> EXPR [489:39]
4860 | | | | | `--IDENT -> MSG_ERROR [489:39]
4861 | | | | |--COMMA -> , [489:48]
4862 | | | | |--EXPR -> EXPR [489:50]
4863 | | | | | `--STRING_LITERAL -> "method call lparen" [489:50]
4864 | | | | |--COMMA -> , [489:70]
4865 | | | | |--EXPR -> EXPR [489:72]
4866 | | | | | `--NUM_INT -> 4 [489:72]
4867 | | | | |--COMMA -> , [489:73]
4868 | | | | `--EXPR -> EXPR [489:75]
4869 | | | | `--NUM_INT -> 6 [489:75]
4870 | | | `--RPAREN -> ) [489:76]
4871 | | |--COMMA -> , [489:77]
4872 | | |--EXPR -> EXPR [490:21]
4873 | | | `--PLUS -> + [490:21]
4874 | | | |--STRING_LITERAL -> "62:5: " [490:12]
4875 | | | `--METHOD_CALL -> ( [490:38]
4876 | | | |--IDENT -> getCheckMessage [490:23]
4877 | | | |--ELIST -> ELIST [490:39]
4878 | | | | |--EXPR -> EXPR [490:39]
4879 | | | | | `--IDENT -> MSG_ERROR [490:39]
4880 | | | | |--COMMA -> , [490:48]
4881 | | | | |--EXPR -> EXPR [490:50]
4882 | | | | | `--STRING_LITERAL -> "." [490:50]
4883 | | | | |--COMMA -> , [490:53]
4884 | | | | |--EXPR -> EXPR [490:55]
4885 | | | | | `--NUM_INT -> 4 [490:55]
4886 | | | | |--COMMA -> , [490:56]
4887 | | | | `--EXPR -> EXPR [490:58]
4888 | | | | `--NUM_INT -> 10 [490:58]
4889 | | | `--RPAREN -> ) [490:60]
4890 | | |--COMMA -> , [490:61]
4891 | | |--EXPR -> EXPR [491:21]
4892 | | | `--PLUS -> + [491:21]
4893 | | | |--STRING_LITERAL -> "63:5: " [491:12]
4894 | | | `--METHOD_CALL -> ( [491:38]
4895 | | | |--IDENT -> getCheckMessage [491:23]
4896 | | | |--ELIST -> ELIST [491:39]
4897 | | | | |--EXPR -> EXPR [491:39]
4898 | | | | | `--IDENT -> MSG_CHILD_ERROR [491:39]
4899 | | | | |--COMMA -> , [491:54]
4900 | | | | |--EXPR -> EXPR [491:56]
4901 | | | | | `--STRING_LITERAL -> "method call" [491:56]
4902 | | | | |--COMMA -> , [491:69]
4903 | | | | |--EXPR -> EXPR [491:71]
4904 | | | | | `--NUM_INT -> 4 [491:71]
4905 | | | | |--COMMA -> , [491:72]
4906 | | | | `--EXPR -> EXPR [491:74]
4907 | | | | `--NUM_INT -> 8 [491:74]
4908 | | | `--RPAREN -> ) [491:75]
4909 | | |--COMMA -> , [491:76]
4910 | | |--EXPR -> EXPR [492:21]
4911 | | | `--PLUS -> + [492:21]
4912 | | | |--STRING_LITERAL -> "68:5: " [492:12]
4913 | | | `--METHOD_CALL -> ( [492:38]
4914 | | | |--IDENT -> getCheckMessage [492:23]
4915 | | | |--ELIST -> ELIST [492:39]
4916 | | | | |--EXPR -> EXPR [492:39]
4917 | | | | | `--IDENT -> MSG_ERROR [492:39]
4918 | | | | |--COMMA -> , [492:48]
4919 | | | | |--EXPR -> EXPR [492:50]
4920 | | | | | `--STRING_LITERAL -> "super" [492:50]
4921 | | | | |--COMMA -> , [492:57]
4922 | | | | |--EXPR -> EXPR [492:59]
4923 | | | | | `--NUM_INT -> 4 [492:59]
4924 | | | | |--COMMA -> , [492:60]
4925 | | | | `--EXPR -> EXPR [492:62]
4926 | | | | `--NUM_INT -> 10 [492:62]
4927 | | | `--RPAREN -> ) [492:64]
4928 | | |--COMMA -> , [492:65]
4929 | | |--EXPR -> EXPR [493:21]
4930 | | | `--PLUS -> + [493:21]
4931 | | | |--STRING_LITERAL -> "69:5: " [493:12]
4932 | | | `--METHOD_CALL -> ( [493:38]
4933 | | | |--IDENT -> getCheckMessage [493:23]
4934 | | | |--ELIST -> ELIST [493:39]
4935 | | | | |--EXPR -> EXPR [493:39]
4936 | | | | | `--IDENT -> MSG_CHILD_ERROR [493:39]
4937 | | | | |--COMMA -> , [493:54]
4938 | | | | |--EXPR -> EXPR [493:56]
4939 | | | | | `--STRING_LITERAL -> "method call" [493:56]
4940 | | | | |--COMMA -> , [493:69]
4941 | | | | |--EXPR -> EXPR [493:71]
4942 | | | | | `--NUM_INT -> 4 [493:71]
4943 | | | | |--COMMA -> , [493:72]
4944 | | | | `--EXPR -> EXPR [493:74]
4945 | | | | `--NUM_INT -> 8 [493:74]
4946 | | | `--RPAREN -> ) [493:75]
4947 | | |--COMMA -> , [493:76]
4948 | | |--EXPR -> EXPR [494:22]
4949 | | | `--PLUS -> + [494:22]
4950 | | | |--STRING_LITERAL -> "75:11: " [494:12]
4951 | | | `--METHOD_CALL -> ( [494:39]
4952 | | | |--IDENT -> getCheckMessage [494:24]
4953 | | | |--ELIST -> ELIST [494:40]
4954 | | | | |--EXPR -> EXPR [494:40]
4955 | | | | | `--IDENT -> MSG_ERROR_MULTI [494:40]
4956 | | | | |--COMMA -> , [494:55]
4957 | | | | |--EXPR -> EXPR [494:57]
4958 | | | | | `--STRING_LITERAL -> "lambda arguments" [494:57]
4959 | | | | |--COMMA -> , [494:75]
4960 | | | | |--EXPR -> EXPR [494:77]
4961 | | | | | `--NUM_INT -> 10 [494:77]
4962 | | | | |--COMMA -> , [494:79]
4963 | | | | `--EXPR -> EXPR [494:81]
4964 | | | | `--STRING_LITERAL -> "12, 14" [494:81]
4965 | | | `--RPAREN -> ) [494:89]
4966 | | |--COMMA -> , [494:90]
4967 | | `--RCURLY -> } [495:8]
4968 | |--SEMI -> ; [495:9]
4969 | |--EXPR -> EXPR [496:19]
4970 | | `--METHOD_CALL -> ( [496:19]
4971 | | |--IDENT -> verifyWarns [496:8]
4972 | | |--ELIST -> ELIST [496:20]
4973 | | | |--EXPR -> EXPR [496:20]
4974 | | | | `--IDENT -> checkConfig [496:20]
4975 | | | |--COMMA -> , [496:31]
4976 | | | |--EXPR -> EXPR [496:40]
4977 | | | | `--METHOD_CALL -> ( [496:40]
4978 | | | | |--IDENT -> getPath [496:33]
4979 | | | | |--ELIST -> ELIST [496:41]
4980 | | | | | `--EXPR -> EXPR [496:41]
4981 | | | | | `--STRING_LITERAL -> "InputIndentationCtorCall.java" [496:41]
4982 | | | | `--RPAREN -> ) [496:72]
4983 | | | |--COMMA -> , [496:73]
4984 | | | `--EXPR -> EXPR [496:75]
4985 | | | `--IDENT -> expected [496:75]
4986 | | `--RPAREN -> ) [496:83]
4987 | |--SEMI -> ; [496:84]
4988 | `--RCURLY -> } [497:4]
4989 |--METHOD_DEF -> METHOD_DEF [499:4]
4990 | |--MODIFIERS -> MODIFIERS [499:4]
4991 | | |--ANNOTATION -> ANNOTATION [499:4]
4992 | | | |--AT -> @ [499:4]
4993 | | | `--IDENT -> Test [499:5]
4994 | | `--LITERAL_PUBLIC -> public [500:4]
4995 | |--TYPE -> TYPE [500:11]
4996 | | `--LITERAL_VOID -> void [500:11]
4997 | |--IDENT -> testMembers [500:16]
4998 | |--LPAREN -> ( [500:27]
4999 | |--PARAMETERS -> PARAMETERS [500:28]
5000 | |--RPAREN -> ) [500:28]
5001 | |--LITERAL_THROWS -> throws [500:30]
5002 | | `--IDENT -> Exception [500:37]
5003 | `--SLIST -> { [500:47]
5004 | |--VARIABLE_DEF -> VARIABLE_DEF [501:8]
5005 | | |--MODIFIERS -> MODIFIERS [501:8]
5006 | | | `--FINAL -> final [501:8]
5007 | | |--TYPE -> TYPE [501:14]
5008 | | | `--IDENT -> DefaultConfiguration [501:14]
5009 | | |--IDENT -> checkConfig [501:35]
5010 | | `--ASSIGN -> = [501:47]
5011 | | `--EXPR -> EXPR [501:67]
5012 | | `--METHOD_CALL -> ( [501:67]
5013 | | |--IDENT -> createModuleConfig [501:49]
5014 | | |--ELIST -> ELIST [501:84]
5015 | | | `--EXPR -> EXPR [501:84]
5016 | | | `--DOT -> . [501:84]
5017 | | | |--IDENT -> IndentationCheck [501:68]
5018 | | | `--LITERAL_CLASS -> class [501:85]
5019 | | `--RPAREN -> ) [501:90]
5020 | |--SEMI -> ; [501:91]
5021 | |--EXPR -> EXPR [503:32]
5022 | | `--METHOD_CALL -> ( [503:32]
5023 | | |--DOT -> . [503:19]
5024 | | | |--IDENT -> checkConfig [503:8]
5025 | | | `--IDENT -> addAttribute [503:20]
5026 | | |--ELIST -> ELIST [503:33]
5027 | | | |--EXPR -> EXPR [503:33]
5028 | | | | `--STRING_LITERAL -> "arrayInitIndent" [503:33]
5029 | | | |--COMMA -> , [503:50]
5030 | | | `--EXPR -> EXPR [503:52]
5031 | | | `--STRING_LITERAL -> "4" [503:52]
5032 | | `--RPAREN -> ) [503:55]
5033 | |--SEMI -> ; [503:56]
5034 | |--EXPR -> EXPR [504:32]
5035 | | `--METHOD_CALL -> ( [504:32]
5036 | | |--DOT -> . [504:19]
5037 | | | |--IDENT -> checkConfig [504:8]
5038 | | | `--IDENT -> addAttribute [504:20]
5039 | | |--ELIST -> ELIST [504:33]
5040 | | | |--EXPR -> EXPR [504:33]
5041 | | | | `--STRING_LITERAL -> "basicOffset" [504:33]
5042 | | | |--COMMA -> , [504:46]
5043 | | | `--EXPR -> EXPR [504:48]
5044 | | | `--STRING_LITERAL -> "2" [504:48]
5045 | | `--RPAREN -> ) [504:51]
5046 | |--SEMI -> ; [504:52]
5047 | |--EXPR -> EXPR [505:32]
5048 | | `--METHOD_CALL -> ( [505:32]
5049 | | |--DOT -> . [505:19]
5050 | | | |--IDENT -> checkConfig [505:8]
5051 | | | `--IDENT -> addAttribute [505:20]
5052 | | |--ELIST -> ELIST [505:33]
5053 | | | |--EXPR -> EXPR [505:33]
5054 | | | | `--STRING_LITERAL -> "braceAdjustment" [505:33]
5055 | | | |--COMMA -> , [505:50]
5056 | | | `--EXPR -> EXPR [505:52]
5057 | | | `--STRING_LITERAL -> "0" [505:52]
5058 | | `--RPAREN -> ) [505:55]
5059 | |--SEMI -> ; [505:56]
5060 | |--EXPR -> EXPR [506:32]
5061 | | `--METHOD_CALL -> ( [506:32]
5062 | | |--DOT -> . [506:19]
5063 | | | |--IDENT -> checkConfig [506:8]
5064 | | | `--IDENT -> addAttribute [506:20]
5065 | | |--ELIST -> ELIST [506:33]
5066 | | | |--EXPR -> EXPR [506:33]
5067 | | | | `--STRING_LITERAL -> "caseIndent" [506:33]
5068 | | | |--COMMA -> , [506:45]
5069 | | | `--EXPR -> EXPR [506:47]
5070 | | | `--STRING_LITERAL -> "4" [506:47]
5071 | | `--RPAREN -> ) [506:50]
5072 | |--SEMI -> ; [506:51]
5073 | |--EXPR -> EXPR [507:32]
5074 | | `--METHOD_CALL -> ( [507:32]
5075 | | |--DOT -> . [507:19]
5076 | | | |--IDENT -> checkConfig [507:8]
5077 | | | `--IDENT -> addAttribute [507:20]
5078 | | |--ELIST -> ELIST [507:33]
5079 | | | |--EXPR -> EXPR [507:33]
5080 | | | | `--STRING_LITERAL -> "forceStrictCondition" [507:33]
5081 | | | |--COMMA -> , [507:55]
5082 | | | `--EXPR -> EXPR [507:57]
5083 | | | `--STRING_LITERAL -> "false" [507:57]
5084 | | `--RPAREN -> ) [507:64]
5085 | |--SEMI -> ; [507:65]
5086 | |--EXPR -> EXPR [508:32]
5087 | | `--METHOD_CALL -> ( [508:32]
5088 | | |--DOT -> . [508:19]
5089 | | | |--IDENT -> checkConfig [508:8]
5090 | | | `--IDENT -> addAttribute [508:20]
5091 | | |--ELIST -> ELIST [508:33]
5092 | | | |--EXPR -> EXPR [508:33]
5093 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [508:33]
5094 | | | |--COMMA -> , [508:58]
5095 | | | `--EXPR -> EXPR [508:60]
5096 | | | `--STRING_LITERAL -> "4" [508:60]
5097 | | `--RPAREN -> ) [508:63]
5098 | |--SEMI -> ; [508:64]
5099 | |--EXPR -> EXPR [509:32]
5100 | | `--METHOD_CALL -> ( [509:32]
5101 | | |--DOT -> . [509:19]
5102 | | | |--IDENT -> checkConfig [509:8]
5103 | | | `--IDENT -> addAttribute [509:20]
5104 | | |--ELIST -> ELIST [509:33]
5105 | | | |--EXPR -> EXPR [509:33]
5106 | | | | `--STRING_LITERAL -> "tabWidth" [509:33]
5107 | | | |--COMMA -> , [509:43]
5108 | | | `--EXPR -> EXPR [509:45]
5109 | | | `--STRING_LITERAL -> "4" [509:45]
5110 | | `--RPAREN -> ) [509:48]
5111 | |--SEMI -> ; [509:49]
5112 | |--EXPR -> EXPR [510:32]
5113 | | `--METHOD_CALL -> ( [510:32]
5114 | | |--DOT -> . [510:19]
5115 | | | |--IDENT -> checkConfig [510:8]
5116 | | | `--IDENT -> addAttribute [510:20]
5117 | | |--ELIST -> ELIST [510:33]
5118 | | | |--EXPR -> EXPR [510:33]
5119 | | | | `--STRING_LITERAL -> "throwsIndent" [510:33]
5120 | | | |--COMMA -> , [510:47]
5121 | | | `--EXPR -> EXPR [510:49]
5122 | | | `--STRING_LITERAL -> "4" [510:49]
5123 | | `--RPAREN -> ) [510:52]
5124 | |--SEMI -> ; [510:53]
5125 | |--VARIABLE_DEF -> VARIABLE_DEF [511:8]
5126 | | |--MODIFIERS -> MODIFIERS [511:8]
5127 | | | `--FINAL -> final [511:8]
5128 | | |--TYPE -> TYPE [511:20]
5129 | | | `--ARRAY_DECLARATOR -> [ [511:20]
5130 | | | |--IDENT -> String [511:14]
5131 | | | `--RBRACK -> ] [511:21]
5132 | | |--IDENT -> expected [511:23]
5133 | | `--ASSIGN -> = [511:32]
5134 | | `--ARRAY_INIT -> { [511:34]
5135 | | |--EXPR -> EXPR [512:21]
5136 | | | `--PLUS -> + [512:21]
5137 | | | |--STRING_LITERAL -> "22:6: " [512:12]
5138 | | | `--METHOD_CALL -> ( [512:38]
5139 | | | |--IDENT -> getCheckMessage [512:23]
5140 | | | |--ELIST -> ELIST [512:39]
5141 | | | | |--EXPR -> EXPR [512:39]
5142 | | | | | `--IDENT -> MSG_ERROR [512:39]
5143 | | | | |--COMMA -> , [512:48]
5144 | | | | |--EXPR -> EXPR [512:50]
5145 | | | | | `--STRING_LITERAL -> "=" [512:50]
5146 | | | | |--COMMA -> , [512:53]
5147 | | | | |--EXPR -> EXPR [512:55]
5148 | | | | | `--NUM_INT -> 5 [512:55]
5149 | | | | |--COMMA -> , [512:56]
5150 | | | | `--EXPR -> EXPR [512:58]
5151 | | | | `--NUM_INT -> 6 [512:58]
5152 | | | `--RPAREN -> ) [512:59]
5153 | | |--COMMA -> , [512:60]
5154 | | |--EXPR -> EXPR [513:21]
5155 | | | `--PLUS -> + [513:21]
5156 | | | |--STRING_LITERAL -> "57:4: " [513:12]
5157 | | | `--METHOD_CALL -> ( [513:38]
5158 | | | |--IDENT -> getCheckMessage [513:23]
5159 | | | |--ELIST -> ELIST [513:39]
5160 | | | | |--EXPR -> EXPR [513:39]
5161 | | | | | `--IDENT -> MSG_ERROR [513:39]
5162 | | | | |--COMMA -> , [513:48]
5163 | | | | |--EXPR -> EXPR [513:50]
5164 | | | | | `--STRING_LITERAL -> "class def rcurly" [513:50]
5165 | | | | |--COMMA -> , [513:68]
5166 | | | | |--EXPR -> EXPR [513:70]
5167 | | | | | `--NUM_INT -> 3 [513:70]
5168 | | | | |--COMMA -> , [513:71]
5169 | | | | `--EXPR -> EXPR [513:73]
5170 | | | | `--NUM_INT -> 2 [513:73]
5171 | | | `--RPAREN -> ) [513:74]
5172 | | |--COMMA -> , [513:75]
5173 | | `--RCURLY -> } [514:8]
5174 | |--SEMI -> ; [514:9]
5175 | |--EXPR -> EXPR [516:19]
5176 | | `--METHOD_CALL -> ( [516:19]
5177 | | |--IDENT -> verifyWarns [516:8]
5178 | | |--ELIST -> ELIST [516:20]
5179 | | | |--EXPR -> EXPR [516:20]
5180 | | | | `--IDENT -> checkConfig [516:20]
5181 | | | |--COMMA -> , [516:31]
5182 | | | |--EXPR -> EXPR [516:40]
5183 | | | | `--METHOD_CALL -> ( [516:40]
5184 | | | | |--IDENT -> getPath [516:33]
5185 | | | | |--ELIST -> ELIST [516:41]
5186 | | | | | `--EXPR -> EXPR [516:41]
5187 | | | | | `--STRING_LITERAL -> "InputIndentationMembers.java" [516:41]
5188 | | | | `--RPAREN -> ) [516:71]
5189 | | | |--COMMA -> , [516:72]
5190 | | | `--EXPR -> EXPR [516:74]
5191 | | | `--IDENT -> expected [516:74]
5192 | | `--RPAREN -> ) [516:82]
5193 | |--SEMI -> ; [516:83]
5194 | `--RCURLY -> } [517:4]
5195 |--METHOD_DEF -> METHOD_DEF [519:4]
5196 | |--MODIFIERS -> MODIFIERS [519:4]
5197 | | |--ANNOTATION -> ANNOTATION [519:4]
5198 | | | |--AT -> @ [519:4]
5199 | | | `--IDENT -> Test [519:5]
5200 | | `--LITERAL_PUBLIC -> public [520:4]
5201 | |--TYPE -> TYPE [520:11]
5202 | | `--LITERAL_VOID -> void [520:11]
5203 | |--IDENT -> testAnnotationArrayInit [520:16]
5204 | |--LPAREN -> ( [520:39]
5205 | |--PARAMETERS -> PARAMETERS [520:40]
5206 | |--RPAREN -> ) [520:40]
5207 | |--LITERAL_THROWS -> throws [520:42]
5208 | | `--IDENT -> Exception [520:49]
5209 | `--SLIST -> { [520:59]
5210 | |--VARIABLE_DEF -> VARIABLE_DEF [521:8]
5211 | | |--MODIFIERS -> MODIFIERS [521:8]
5212 | | | `--FINAL -> final [521:8]
5213 | | |--TYPE -> TYPE [521:14]
5214 | | | `--IDENT -> DefaultConfiguration [521:14]
5215 | | |--IDENT -> checkConfig [521:35]
5216 | | `--ASSIGN -> = [521:47]
5217 | | `--EXPR -> EXPR [521:67]
5218 | | `--METHOD_CALL -> ( [521:67]
5219 | | |--IDENT -> createModuleConfig [521:49]
5220 | | |--ELIST -> ELIST [521:84]
5221 | | | `--EXPR -> EXPR [521:84]
5222 | | | `--DOT -> . [521:84]
5223 | | | |--IDENT -> IndentationCheck [521:68]
5224 | | | `--LITERAL_CLASS -> class [521:85]
5225 | | `--RPAREN -> ) [521:90]
5226 | |--SEMI -> ; [521:91]
5227 | |--EXPR -> EXPR [523:32]
5228 | | `--METHOD_CALL -> ( [523:32]
5229 | | |--DOT -> . [523:19]
5230 | | | |--IDENT -> checkConfig [523:8]
5231 | | | `--IDENT -> addAttribute [523:20]
5232 | | |--ELIST -> ELIST [523:33]
5233 | | | |--EXPR -> EXPR [523:33]
5234 | | | | `--STRING_LITERAL -> "arrayInitIndent" [523:33]
5235 | | | |--COMMA -> , [523:50]
5236 | | | `--EXPR -> EXPR [523:52]
5237 | | | `--STRING_LITERAL -> "6" [523:52]
5238 | | `--RPAREN -> ) [523:55]
5239 | |--SEMI -> ; [523:56]
5240 | |--EXPR -> EXPR [524:32]
5241 | | `--METHOD_CALL -> ( [524:32]
5242 | | |--DOT -> . [524:19]
5243 | | | |--IDENT -> checkConfig [524:8]
5244 | | | `--IDENT -> addAttribute [524:20]
5245 | | |--ELIST -> ELIST [524:33]
5246 | | | |--EXPR -> EXPR [524:33]
5247 | | | | `--STRING_LITERAL -> "basicOffset" [524:33]
5248 | | | |--COMMA -> , [524:46]
5249 | | | `--EXPR -> EXPR [524:48]
5250 | | | `--STRING_LITERAL -> "2" [524:48]
5251 | | `--RPAREN -> ) [524:51]
5252 | |--SEMI -> ; [524:52]
5253 | |--EXPR -> EXPR [525:32]
5254 | | `--METHOD_CALL -> ( [525:32]
5255 | | |--DOT -> . [525:19]
5256 | | | |--IDENT -> checkConfig [525:8]
5257 | | | `--IDENT -> addAttribute [525:20]
5258 | | |--ELIST -> ELIST [525:33]
5259 | | | |--EXPR -> EXPR [525:33]
5260 | | | | `--STRING_LITERAL -> "braceAdjustment" [525:33]
5261 | | | |--COMMA -> , [525:50]
5262 | | | `--EXPR -> EXPR [525:52]
5263 | | | `--STRING_LITERAL -> "0" [525:52]
5264 | | `--RPAREN -> ) [525:55]
5265 | |--SEMI -> ; [525:56]
5266 | |--EXPR -> EXPR [526:32]
5267 | | `--METHOD_CALL -> ( [526:32]
5268 | | |--DOT -> . [526:19]
5269 | | | |--IDENT -> checkConfig [526:8]
5270 | | | `--IDENT -> addAttribute [526:20]
5271 | | |--ELIST -> ELIST [526:33]
5272 | | | |--EXPR -> EXPR [526:33]
5273 | | | | `--STRING_LITERAL -> "caseIndent" [526:33]
5274 | | | |--COMMA -> , [526:45]
5275 | | | `--EXPR -> EXPR [526:47]
5276 | | | `--STRING_LITERAL -> "4" [526:47]
5277 | | `--RPAREN -> ) [526:50]
5278 | |--SEMI -> ; [526:51]
5279 | |--EXPR -> EXPR [527:32]
5280 | | `--METHOD_CALL -> ( [527:32]
5281 | | |--DOT -> . [527:19]
5282 | | | |--IDENT -> checkConfig [527:8]
5283 | | | `--IDENT -> addAttribute [527:20]
5284 | | |--ELIST -> ELIST [527:33]
5285 | | | |--EXPR -> EXPR [527:33]
5286 | | | | `--STRING_LITERAL -> "forceStrictCondition" [527:33]
5287 | | | |--COMMA -> , [527:55]
5288 | | | `--EXPR -> EXPR [527:57]
5289 | | | `--STRING_LITERAL -> "false" [527:57]
5290 | | `--RPAREN -> ) [527:64]
5291 | |--SEMI -> ; [527:65]
5292 | |--EXPR -> EXPR [528:32]
5293 | | `--METHOD_CALL -> ( [528:32]
5294 | | |--DOT -> . [528:19]
5295 | | | |--IDENT -> checkConfig [528:8]
5296 | | | `--IDENT -> addAttribute [528:20]
5297 | | |--ELIST -> ELIST [528:33]
5298 | | | |--EXPR -> EXPR [528:33]
5299 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [528:33]
5300 | | | |--COMMA -> , [528:58]
5301 | | | `--EXPR -> EXPR [528:60]
5302 | | | `--STRING_LITERAL -> "4" [528:60]
5303 | | `--RPAREN -> ) [528:63]
5304 | |--SEMI -> ; [528:64]
5305 | |--EXPR -> EXPR [529:32]
5306 | | `--METHOD_CALL -> ( [529:32]
5307 | | |--DOT -> . [529:19]
5308 | | | |--IDENT -> checkConfig [529:8]
5309 | | | `--IDENT -> addAttribute [529:20]
5310 | | |--ELIST -> ELIST [529:33]
5311 | | | |--EXPR -> EXPR [529:33]
5312 | | | | `--STRING_LITERAL -> "tabWidth" [529:33]
5313 | | | |--COMMA -> , [529:43]
5314 | | | `--EXPR -> EXPR [529:45]
5315 | | | `--STRING_LITERAL -> "8" [529:45]
5316 | | `--RPAREN -> ) [529:48]
5317 | |--SEMI -> ; [529:49]
5318 | |--EXPR -> EXPR [530:32]
5319 | | `--METHOD_CALL -> ( [530:32]
5320 | | |--DOT -> . [530:19]
5321 | | | |--IDENT -> checkConfig [530:8]
5322 | | | `--IDENT -> addAttribute [530:20]
5323 | | |--ELIST -> ELIST [530:33]
5324 | | | |--EXPR -> EXPR [530:33]
5325 | | | | `--STRING_LITERAL -> "throwsIndent" [530:33]
5326 | | | |--COMMA -> , [530:47]
5327 | | | `--EXPR -> EXPR [530:49]
5328 | | | `--STRING_LITERAL -> "4" [530:49]
5329 | | `--RPAREN -> ) [530:52]
5330 | |--SEMI -> ; [530:53]
5331 | |--VARIABLE_DEF -> VARIABLE_DEF [531:8]
5332 | | |--MODIFIERS -> MODIFIERS [531:8]
5333 | | | `--FINAL -> final [531:8]
5334 | | |--TYPE -> TYPE [531:20]
5335 | | | `--ARRAY_DECLARATOR -> [ [531:20]
5336 | | | |--IDENT -> String [531:14]
5337 | | | `--RBRACK -> ] [531:21]
5338 | | |--IDENT -> expected [531:23]
5339 | | `--ASSIGN -> = [531:32]
5340 | | `--ARRAY_INIT -> { [531:34]
5341 | | |--EXPR -> EXPR [533:21]
5342 | | | `--PLUS -> + [533:21]
5343 | | | |--STRING_LITERAL -> "17:1: " [533:12]
5344 | | | `--METHOD_CALL -> ( [533:38]
5345 | | | |--IDENT -> getCheckMessage [533:23]
5346 | | | |--ELIST -> ELIST [533:39]
5347 | | | | |--EXPR -> EXPR [533:39]
5348 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [533:39]
5349 | | | | |--COMMA -> , [533:60]
5350 | | | | |--EXPR -> EXPR [533:62]
5351 | | | | | `--STRING_LITERAL -> "annotation array initialization" [533:62]
5352 | | | | |--COMMA -> , [533:95]
5353 | | | | |--EXPR -> EXPR [533:97]
5354 | | | | | `--NUM_INT -> 0 [533:97]
5355 | | | | |--COMMA -> , [533:98]
5356 | | | | `--EXPR -> EXPR [534:16]
5357 | | | | `--STRING_LITERAL -> "4, 6, 34, 36" [534:16]
5358 | | | `--RPAREN -> ) [534:30]
5359 | | |--COMMA -> , [534:31]
5360 | | |--EXPR -> EXPR [535:22]
5361 | | | `--PLUS -> + [535:22]
5362 | | | |--STRING_LITERAL -> "22:14: " [535:12]
5363 | | | `--METHOD_CALL -> ( [535:39]
5364 | | | |--IDENT -> getCheckMessage [535:24]
5365 | | | |--ELIST -> ELIST [535:40]
5366 | | | | |--EXPR -> EXPR [535:40]
5367 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [535:40]
5368 | | | | |--COMMA -> , [535:61]
5369 | | | | |--EXPR -> EXPR [535:63]
5370 | | | | | `--STRING_LITERAL -> "annotation array initialization" [535:63]
5371 | | | | |--COMMA -> , [535:96]
5372 | | | | |--EXPR -> EXPR [536:20]
5373 | | | | | `--NUM_INT -> 13 [536:20]
5374 | | | | |--COMMA -> , [536:22]
5375 | | | | `--EXPR -> EXPR [536:24]
5376 | | | | `--STRING_LITERAL -> "4, 6, 34, 36" [536:24]
5377 | | | `--RPAREN -> ) [536:38]
5378 | | |--COMMA -> , [536:39]
5379 | | |--EXPR -> EXPR [537:21]
5380 | | | `--PLUS -> + [537:21]
5381 | | | |--STRING_LITERAL -> "23:3: " [537:12]
5382 | | | `--METHOD_CALL -> ( [537:38]
5383 | | | |--IDENT -> getCheckMessage [537:23]
5384 | | | |--ELIST -> ELIST [537:39]
5385 | | | | |--EXPR -> EXPR [537:39]
5386 | | | | | `--IDENT -> MSG_ERROR_MULTI [537:39]
5387 | | | | |--COMMA -> , [537:54]
5388 | | | | |--EXPR -> EXPR [538:20]
5389 | | | | | `--STRING_LITERAL -> "annotation array initialization rcurly" [538:20]
5390 | | | | |--COMMA -> , [538:60]
5391 | | | | |--EXPR -> EXPR [538:62]
5392 | | | | | `--NUM_INT -> 2 [538:62]
5393 | | | | |--COMMA -> , [538:63]
5394 | | | | `--EXPR -> EXPR [538:65]
5395 | | | | `--STRING_LITERAL -> "0, 4" [538:65]
5396 | | | `--RPAREN -> ) [538:71]
5397 | | |--COMMA -> , [538:72]
5398 | | |--EXPR -> EXPR [539:21]
5399 | | | `--PLUS -> + [539:21]
5400 | | | |--STRING_LITERAL -> "35:7: " [539:12]
5401 | | | `--METHOD_CALL -> ( [539:38]
5402 | | | |--IDENT -> getCheckMessage [539:23]
5403 | | | |--ELIST -> ELIST [539:39]
5404 | | | | |--EXPR -> EXPR [539:39]
5405 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [539:39]
5406 | | | | |--COMMA -> , [539:60]
5407 | | | | |--EXPR -> EXPR [539:62]
5408 | | | | | `--STRING_LITERAL -> "annotation array initialization" [539:62]
5409 | | | | |--COMMA -> , [539:95]
5410 | | | | |--EXPR -> EXPR [539:97]
5411 | | | | | `--NUM_INT -> 6 [539:97]
5412 | | | | |--COMMA -> , [539:98]
5413 | | | | `--EXPR -> EXPR [540:16]
5414 | | | | `--STRING_LITERAL -> "8, 10, 31, 33" [540:16]
5415 | | | `--RPAREN -> ) [540:31]
5416 | | |--COMMA -> , [540:32]
5417 | | |--EXPR -> EXPR [541:21]
5418 | | | `--PLUS -> + [541:21]
5419 | | | |--STRING_LITERAL -> "36:3: " [541:12]
5420 | | | `--METHOD_CALL -> ( [541:38]
5421 | | | |--IDENT -> getCheckMessage [541:23]
5422 | | | |--ELIST -> ELIST [541:39]
5423 | | | | |--EXPR -> EXPR [541:39]
5424 | | | | | `--IDENT -> MSG_ERROR_MULTI [541:39]
5425 | | | | |--COMMA -> , [541:54]
5426 | | | | |--EXPR -> EXPR [542:20]
5427 | | | | | `--STRING_LITERAL -> "annotation array initialization rcurly" [542:20]
5428 | | | | |--COMMA -> , [542:60]
5429 | | | | |--EXPR -> EXPR [542:62]
5430 | | | | | `--NUM_INT -> 2 [542:62]
5431 | | | | |--COMMA -> , [542:63]
5432 | | | | `--EXPR -> EXPR [542:65]
5433 | | | | `--STRING_LITERAL -> "4, 8" [542:65]
5434 | | | `--RPAREN -> ) [542:71]
5435 | | |--COMMA -> , [542:72]
5436 | | |--EXPR -> EXPR [544:21]
5437 | | | `--PLUS -> + [544:21]
5438 | | | |--STRING_LITERAL -> "52:6: " [544:12]
5439 | | | `--METHOD_CALL -> ( [544:38]
5440 | | | |--IDENT -> getCheckMessage [544:23]
5441 | | | |--ELIST -> ELIST [544:39]
5442 | | | | |--EXPR -> EXPR [544:39]
5443 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [544:39]
5444 | | | | |--COMMA -> , [544:60]
5445 | | | | |--EXPR -> EXPR [545:20]
5446 | | | | | `--STRING_LITERAL -> "annotation array initialization" [545:20]
5447 | | | | |--COMMA -> , [545:53]
5448 | | | | |--EXPR -> EXPR [545:55]
5449 | | | | | `--NUM_INT -> 5 [545:55]
5450 | | | | |--COMMA -> , [545:56]
5451 | | | | `--EXPR -> EXPR [545:58]
5452 | | | | `--STRING_LITERAL -> "6, 8, 10" [545:58]
5453 | | | `--RPAREN -> ) [545:68]
5454 | | |--COMMA -> , [545:69]
5455 | | |--EXPR -> EXPR [546:21]
5456 | | | `--PLUS -> + [546:21]
5457 | | | |--STRING_LITERAL -> "54:6: " [546:12]
5458 | | | `--METHOD_CALL -> ( [546:38]
5459 | | | |--IDENT -> getCheckMessage [546:23]
5460 | | | |--ELIST -> ELIST [546:39]
5461 | | | | |--EXPR -> EXPR [546:39]
5462 | | | | | `--IDENT -> MSG_ERROR_MULTI [546:39]
5463 | | | | |--COMMA -> , [546:54]
5464 | | | | |--EXPR -> EXPR [547:20]
5465 | | | | | `--STRING_LITERAL -> "annotation array initialization rcurly" [547:20]
5466 | | | | |--COMMA -> , [547:60]
5467 | | | | |--EXPR -> EXPR [547:62]
5468 | | | | | `--NUM_INT -> 5 [547:62]
5469 | | | | |--COMMA -> , [547:63]
5470 | | | | `--EXPR -> EXPR [547:65]
5471 | | | | `--STRING_LITERAL -> "2, 6" [547:65]
5472 | | | `--RPAREN -> ) [547:71]
5473 | | |--COMMA -> , [547:72]
5474 | | `--RCURLY -> } [548:8]
5475 | |--SEMI -> ; [548:9]
5476 | |--VARIABLE_DEF -> VARIABLE_DEF [549:8]
5477 | | |--MODIFIERS -> MODIFIERS [549:8]
5478 | | | `--FINAL -> final [549:8]
5479 | | |--TYPE -> TYPE [549:14]
5480 | | | `--IDENT -> String [549:14]
5481 | | |--IDENT -> fileName [549:21]
5482 | | `--ASSIGN -> = [549:30]
5483 | | `--EXPR -> EXPR [549:39]
5484 | | `--METHOD_CALL -> ( [549:39]
5485 | | |--IDENT -> getPath [549:32]
5486 | | |--ELIST -> ELIST [549:40]
5487 | | | `--EXPR -> EXPR [549:40]
5488 | | | `--STRING_LITERAL -> "InputIndentationAnnArrInit.java" [549:40]
5489 | | `--RPAREN -> ) [549:73]
5490 | |--SEMI -> ; [549:74]
5491 | |--EXPR -> EXPR [550:19]
5492 | | `--METHOD_CALL -> ( [550:19]
5493 | | |--IDENT -> verifyWarns [550:8]
5494 | | |--ELIST -> ELIST [550:20]
5495 | | | |--EXPR -> EXPR [550:20]
5496 | | | | `--IDENT -> checkConfig [550:20]
5497 | | | |--COMMA -> , [550:31]
5498 | | | |--EXPR -> EXPR [550:33]
5499 | | | | `--IDENT -> fileName [550:33]
5500 | | | |--COMMA -> , [550:41]
5501 | | | `--EXPR -> EXPR [550:43]
5502 | | | `--IDENT -> expected [550:43]
5503 | | `--RPAREN -> ) [550:51]
5504 | |--SEMI -> ; [550:52]
5505 | `--RCURLY -> } [551:4]
5506 |--METHOD_DEF -> METHOD_DEF [553:4]
5507 | |--MODIFIERS -> MODIFIERS [553:4]
5508 | | |--ANNOTATION -> ANNOTATION [553:4]
5509 | | | |--AT -> @ [553:4]
5510 | | | `--IDENT -> Test [553:5]
5511 | | `--LITERAL_PUBLIC -> public [554:4]
5512 | |--TYPE -> TYPE [554:11]
5513 | | `--LITERAL_VOID -> void [554:11]
5514 | |--IDENT -> testAnnotationArrayInitTwo [554:16]
5515 | |--LPAREN -> ( [554:42]
5516 | |--PARAMETERS -> PARAMETERS [554:43]
5517 | |--RPAREN -> ) [554:43]
5518 | |--LITERAL_THROWS -> throws [554:45]
5519 | | `--IDENT -> Exception [554:52]
5520 | `--SLIST -> { [554:62]
5521 | |--VARIABLE_DEF -> VARIABLE_DEF [555:8]
5522 | | |--MODIFIERS -> MODIFIERS [555:8]
5523 | | | `--FINAL -> final [555:8]
5524 | | |--TYPE -> TYPE [555:14]
5525 | | | `--IDENT -> DefaultConfiguration [555:14]
5526 | | |--IDENT -> checkConfig [555:35]
5527 | | `--ASSIGN -> = [555:47]
5528 | | `--EXPR -> EXPR [555:67]
5529 | | `--METHOD_CALL -> ( [555:67]
5530 | | |--IDENT -> createModuleConfig [555:49]
5531 | | |--ELIST -> ELIST [555:84]
5532 | | | `--EXPR -> EXPR [555:84]
5533 | | | `--DOT -> . [555:84]
5534 | | | |--IDENT -> IndentationCheck [555:68]
5535 | | | `--LITERAL_CLASS -> class [555:85]
5536 | | `--RPAREN -> ) [555:90]
5537 | |--SEMI -> ; [555:91]
5538 | |--EXPR -> EXPR [557:32]
5539 | | `--METHOD_CALL -> ( [557:32]
5540 | | |--DOT -> . [557:19]
5541 | | | |--IDENT -> checkConfig [557:8]
5542 | | | `--IDENT -> addAttribute [557:20]
5543 | | |--ELIST -> ELIST [557:33]
5544 | | | |--EXPR -> EXPR [557:33]
5545 | | | | `--STRING_LITERAL -> "arrayInitIndent" [557:33]
5546 | | | |--COMMA -> , [557:50]
5547 | | | `--EXPR -> EXPR [557:52]
5548 | | | `--STRING_LITERAL -> "0" [557:52]
5549 | | `--RPAREN -> ) [557:55]
5550 | |--SEMI -> ; [557:56]
5551 | |--EXPR -> EXPR [558:32]
5552 | | `--METHOD_CALL -> ( [558:32]
5553 | | |--DOT -> . [558:19]
5554 | | | |--IDENT -> checkConfig [558:8]
5555 | | | `--IDENT -> addAttribute [558:20]
5556 | | |--ELIST -> ELIST [558:33]
5557 | | | |--EXPR -> EXPR [558:33]
5558 | | | | `--STRING_LITERAL -> "basicOffset" [558:33]
5559 | | | |--COMMA -> , [558:46]
5560 | | | `--EXPR -> EXPR [558:48]
5561 | | | `--STRING_LITERAL -> "2" [558:48]
5562 | | `--RPAREN -> ) [558:51]
5563 | |--SEMI -> ; [558:52]
5564 | |--EXPR -> EXPR [559:32]
5565 | | `--METHOD_CALL -> ( [559:32]
5566 | | |--DOT -> . [559:19]
5567 | | | |--IDENT -> checkConfig [559:8]
5568 | | | `--IDENT -> addAttribute [559:20]
5569 | | |--ELIST -> ELIST [559:33]
5570 | | | |--EXPR -> EXPR [559:33]
5571 | | | | `--STRING_LITERAL -> "braceAdjustment" [559:33]
5572 | | | |--COMMA -> , [559:50]
5573 | | | `--EXPR -> EXPR [559:52]
5574 | | | `--STRING_LITERAL -> "0" [559:52]
5575 | | `--RPAREN -> ) [559:55]
5576 | |--SEMI -> ; [559:56]
5577 | |--EXPR -> EXPR [560:32]
5578 | | `--METHOD_CALL -> ( [560:32]
5579 | | |--DOT -> . [560:19]
5580 | | | |--IDENT -> checkConfig [560:8]
5581 | | | `--IDENT -> addAttribute [560:20]
5582 | | |--ELIST -> ELIST [560:33]
5583 | | | |--EXPR -> EXPR [560:33]
5584 | | | | `--STRING_LITERAL -> "caseIndent" [560:33]
5585 | | | |--COMMA -> , [560:45]
5586 | | | `--EXPR -> EXPR [560:47]
5587 | | | `--STRING_LITERAL -> "4" [560:47]
5588 | | `--RPAREN -> ) [560:50]
5589 | |--SEMI -> ; [560:51]
5590 | |--EXPR -> EXPR [561:32]
5591 | | `--METHOD_CALL -> ( [561:32]
5592 | | |--DOT -> . [561:19]
5593 | | | |--IDENT -> checkConfig [561:8]
5594 | | | `--IDENT -> addAttribute [561:20]
5595 | | |--ELIST -> ELIST [561:33]
5596 | | | |--EXPR -> EXPR [561:33]
5597 | | | | `--STRING_LITERAL -> "forceStrictCondition" [561:33]
5598 | | | |--COMMA -> , [561:55]
5599 | | | `--EXPR -> EXPR [561:57]
5600 | | | `--STRING_LITERAL -> "false" [561:57]
5601 | | `--RPAREN -> ) [561:64]
5602 | |--SEMI -> ; [561:65]
5603 | |--EXPR -> EXPR [562:32]
5604 | | `--METHOD_CALL -> ( [562:32]
5605 | | |--DOT -> . [562:19]
5606 | | | |--IDENT -> checkConfig [562:8]
5607 | | | `--IDENT -> addAttribute [562:20]
5608 | | |--ELIST -> ELIST [562:33]
5609 | | | |--EXPR -> EXPR [562:33]
5610 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [562:33]
5611 | | | |--COMMA -> , [562:58]
5612 | | | `--EXPR -> EXPR [562:60]
5613 | | | `--STRING_LITERAL -> "0" [562:60]
5614 | | `--RPAREN -> ) [562:63]
5615 | |--SEMI -> ; [562:64]
5616 | |--EXPR -> EXPR [563:32]
5617 | | `--METHOD_CALL -> ( [563:32]
5618 | | |--DOT -> . [563:19]
5619 | | | |--IDENT -> checkConfig [563:8]
5620 | | | `--IDENT -> addAttribute [563:20]
5621 | | |--ELIST -> ELIST [563:33]
5622 | | | |--EXPR -> EXPR [563:33]
5623 | | | | `--STRING_LITERAL -> "tabWidth" [563:33]
5624 | | | |--COMMA -> , [563:43]
5625 | | | `--EXPR -> EXPR [563:45]
5626 | | | `--STRING_LITERAL -> "8" [563:45]
5627 | | `--RPAREN -> ) [563:48]
5628 | |--SEMI -> ; [563:49]
5629 | |--EXPR -> EXPR [564:32]
5630 | | `--METHOD_CALL -> ( [564:32]
5631 | | |--DOT -> . [564:19]
5632 | | | |--IDENT -> checkConfig [564:8]
5633 | | | `--IDENT -> addAttribute [564:20]
5634 | | |--ELIST -> ELIST [564:33]
5635 | | | |--EXPR -> EXPR [564:33]
5636 | | | | `--STRING_LITERAL -> "throwsIndent" [564:33]
5637 | | | |--COMMA -> , [564:47]
5638 | | | `--EXPR -> EXPR [564:49]
5639 | | | `--STRING_LITERAL -> "4" [564:49]
5640 | | `--RPAREN -> ) [564:52]
5641 | |--SEMI -> ; [564:53]
5642 | |--VARIABLE_DEF -> VARIABLE_DEF [565:8]
5643 | | |--MODIFIERS -> MODIFIERS [565:8]
5644 | | | `--FINAL -> final [565:8]
5645 | | |--TYPE -> TYPE [565:20]
5646 | | | `--ARRAY_DECLARATOR -> [ [565:20]
5647 | | | |--IDENT -> String [565:14]
5648 | | | `--RBRACK -> ] [565:21]
5649 | | |--IDENT -> expected [565:23]
5650 | | `--ASSIGN -> = [565:32]
5651 | | `--ARRAY_INIT -> { [565:34]
5652 | | |--EXPR -> EXPR [567:21]
5653 | | | `--PLUS -> + [567:21]
5654 | | | |--STRING_LITERAL -> "17:5: " [567:12]
5655 | | | `--METHOD_CALL -> ( [567:38]
5656 | | | |--IDENT -> getCheckMessage [567:23]
5657 | | | |--ELIST -> ELIST [567:39]
5658 | | | | |--EXPR -> EXPR [567:39]
5659 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [567:39]
5660 | | | | |--COMMA -> , [567:60]
5661 | | | | |--EXPR -> EXPR [568:16]
5662 | | | | | `--STRING_LITERAL -> "annotation array initialization" [568:16]
5663 | | | | |--COMMA -> , [568:49]
5664 | | | | |--EXPR -> EXPR [568:51]
5665 | | | | | `--NUM_INT -> 4 [568:51]
5666 | | | | |--COMMA -> , [568:52]
5667 | | | | `--EXPR -> EXPR [568:54]
5668 | | | | `--STRING_LITERAL -> "0, 33, 35" [568:54]
5669 | | | `--RPAREN -> ) [568:65]
5670 | | |--COMMA -> , [568:66]
5671 | | |--EXPR -> EXPR [569:21]
5672 | | | `--PLUS -> + [569:21]
5673 | | | |--STRING_LITERAL -> "30:9: " [569:12]
5674 | | | `--METHOD_CALL -> ( [569:38]
5675 | | | |--IDENT -> getCheckMessage [569:23]
5676 | | | |--ELIST -> ELIST [569:39]
5677 | | | | |--EXPR -> EXPR [569:39]
5678 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [569:39]
5679 | | | | |--COMMA -> , [569:60]
5680 | | | | |--EXPR -> EXPR [570:16]
5681 | | | | | `--STRING_LITERAL -> "annotation array initialization" [570:16]
5682 | | | | |--COMMA -> , [570:49]
5683 | | | | |--EXPR -> EXPR [570:51]
5684 | | | | | `--NUM_INT -> 8 [570:51]
5685 | | | | |--COMMA -> , [570:52]
5686 | | | | `--EXPR -> EXPR [570:54]
5687 | | | | `--STRING_LITERAL -> "4, 29, 31" [570:54]
5688 | | | `--RPAREN -> ) [570:65]
5689 | | |--COMMA -> , [570:66]
5690 | | |--EXPR -> EXPR [571:21]
5691 | | | `--PLUS -> + [571:21]
5692 | | | |--STRING_LITERAL -> "32:3: " [571:12]
5693 | | | `--METHOD_CALL -> ( [571:38]
5694 | | | |--IDENT -> getCheckMessage [571:23]
5695 | | | |--ELIST -> ELIST [571:39]
5696 | | | | |--EXPR -> EXPR [571:39]
5697 | | | | | `--IDENT -> MSG_ERROR [571:39]
5698 | | | | |--COMMA -> , [571:48]
5699 | | | | |--EXPR -> EXPR [572:16]
5700 | | | | | `--STRING_LITERAL -> "annotation array initialization rcurly" [572:16]
5701 | | | | |--COMMA -> , [572:56]
5702 | | | | |--EXPR -> EXPR [572:58]
5703 | | | | | `--NUM_INT -> 2 [572:58]
5704 | | | | |--COMMA -> , [572:59]
5705 | | | | `--EXPR -> EXPR [572:61]
5706 | | | | `--NUM_INT -> 4 [572:61]
5707 | | | `--RPAREN -> ) [572:62]
5708 | | |--COMMA -> , [572:63]
5709 | | |--EXPR -> EXPR [573:21]
5710 | | | `--PLUS -> + [573:21]
5711 | | | |--STRING_LITERAL -> "47:7: " [573:12]
5712 | | | `--METHOD_CALL -> ( [573:38]
5713 | | | |--IDENT -> getCheckMessage [573:23]
5714 | | | |--ELIST -> ELIST [573:39]
5715 | | | | |--EXPR -> EXPR [573:39]
5716 | | | | | `--IDENT -> MSG_ERROR [573:39]
5717 | | | | |--COMMA -> , [573:48]
5718 | | | | |--EXPR -> EXPR [574:16]
5719 | | | | | `--STRING_LITERAL -> "annotation array initialization lcurly" [574:16]
5720 | | | | |--COMMA -> , [574:56]
5721 | | | | |--EXPR -> EXPR [574:58]
5722 | | | | | `--NUM_INT -> 6 [574:58]
5723 | | | | |--COMMA -> , [574:59]
5724 | | | | `--EXPR -> EXPR [574:61]
5725 | | | | `--NUM_INT -> 2 [574:61]
5726 | | | `--RPAREN -> ) [574:62]
5727 | | |--COMMA -> , [574:63]
5728 | | |--EXPR -> EXPR [575:21]
5729 | | | `--PLUS -> + [575:21]
5730 | | | |--STRING_LITERAL -> "49:5: " [575:12]
5731 | | | `--METHOD_CALL -> ( [575:38]
5732 | | | |--IDENT -> getCheckMessage [575:23]
5733 | | | |--ELIST -> ELIST [575:39]
5734 | | | | |--EXPR -> EXPR [575:39]
5735 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [575:39]
5736 | | | | |--COMMA -> , [575:60]
5737 | | | | |--EXPR -> EXPR [576:16]
5738 | | | | | `--STRING_LITERAL -> "annotation array initialization" [576:16]
5739 | | | | |--COMMA -> , [576:49]
5740 | | | | |--EXPR -> EXPR [576:51]
5741 | | | | | `--NUM_INT -> 4 [576:51]
5742 | | | | |--COMMA -> , [576:52]
5743 | | | | `--EXPR -> EXPR [576:54]
5744 | | | | `--STRING_LITERAL -> "2, 6, 8" [576:54]
5745 | | | `--RPAREN -> ) [576:63]
5746 | | |--COMMA -> , [576:64]
5747 | | `--RCURLY -> } [577:8]
5748 | |--SEMI -> ; [577:9]
5749 | |--VARIABLE_DEF -> VARIABLE_DEF [578:8]
5750 | | |--MODIFIERS -> MODIFIERS [578:8]
5751 | | | `--FINAL -> final [578:8]
5752 | | |--TYPE -> TYPE [578:14]
5753 | | | `--IDENT -> String [578:14]
5754 | | |--IDENT -> fileName [578:21]
5755 | | `--ASSIGN -> = [578:30]
5756 | | `--EXPR -> EXPR [578:39]
5757 | | `--METHOD_CALL -> ( [578:39]
5758 | | |--IDENT -> getPath [578:32]
5759 | | |--ELIST -> ELIST [578:40]
5760 | | | `--EXPR -> EXPR [578:40]
5761 | | | `--STRING_LITERAL -> "InputIndentationAnnArrInit2.java" [578:40]
5762 | | `--RPAREN -> ) [578:74]
5763 | |--SEMI -> ; [578:75]
5764 | |--EXPR -> EXPR [579:19]
5765 | | `--METHOD_CALL -> ( [579:19]
5766 | | |--IDENT -> verifyWarns [579:8]
5767 | | |--ELIST -> ELIST [579:20]
5768 | | | |--EXPR -> EXPR [579:20]
5769 | | | | `--IDENT -> checkConfig [579:20]
5770 | | | |--COMMA -> , [579:31]
5771 | | | |--EXPR -> EXPR [579:33]
5772 | | | | `--IDENT -> fileName [579:33]
5773 | | | |--COMMA -> , [579:41]
5774 | | | `--EXPR -> EXPR [579:43]
5775 | | | `--IDENT -> expected [579:43]
5776 | | `--RPAREN -> ) [579:51]
5777 | |--SEMI -> ; [579:52]
5778 | `--RCURLY -> } [580:4]
5779 |--METHOD_DEF -> METHOD_DEF [582:4]
5780 | |--MODIFIERS -> MODIFIERS [582:4]
5781 | | |--ANNOTATION -> ANNOTATION [582:4]
5782 | | | |--AT -> @ [582:4]
5783 | | | `--IDENT -> Test [582:5]
5784 | | `--LITERAL_PUBLIC -> public [583:4]
5785 | |--TYPE -> TYPE [583:11]
5786 | | `--LITERAL_VOID -> void [583:11]
5787 | |--IDENT -> testOddAnnotations [583:16]
5788 | |--LPAREN -> ( [583:34]
5789 | |--PARAMETERS -> PARAMETERS [583:35]
5790 | |--RPAREN -> ) [583:35]
5791 | |--LITERAL_THROWS -> throws [584:12]
5792 | | `--IDENT -> Exception [584:19]
5793 | `--SLIST -> { [584:29]
5794 | |--VARIABLE_DEF -> VARIABLE_DEF [585:8]
5795 | | |--MODIFIERS -> MODIFIERS [585:8]
5796 | | | `--FINAL -> final [585:8]
5797 | | |--TYPE -> TYPE [585:14]
5798 | | | `--IDENT -> DefaultConfiguration [585:14]
5799 | | |--IDENT -> checkConfig [585:35]
5800 | | `--ASSIGN -> = [585:47]
5801 | | `--EXPR -> EXPR [585:67]
5802 | | `--METHOD_CALL -> ( [585:67]
5803 | | |--IDENT -> createModuleConfig [585:49]
5804 | | |--ELIST -> ELIST [585:84]
5805 | | | `--EXPR -> EXPR [585:84]
5806 | | | `--DOT -> . [585:84]
5807 | | | |--IDENT -> IndentationCheck [585:68]
5808 | | | `--LITERAL_CLASS -> class [585:85]
5809 | | `--RPAREN -> ) [585:90]
5810 | |--SEMI -> ; [585:91]
5811 | |--EXPR -> EXPR [587:32]
5812 | | `--METHOD_CALL -> ( [587:32]
5813 | | |--DOT -> . [587:19]
5814 | | | |--IDENT -> checkConfig [587:8]
5815 | | | `--IDENT -> addAttribute [587:20]
5816 | | |--ELIST -> ELIST [587:33]
5817 | | | |--EXPR -> EXPR [587:33]
5818 | | | | `--STRING_LITERAL -> "arrayInitIndent" [587:33]
5819 | | | |--COMMA -> , [587:50]
5820 | | | `--EXPR -> EXPR [587:52]
5821 | | | `--STRING_LITERAL -> "3" [587:52]
5822 | | `--RPAREN -> ) [587:55]
5823 | |--SEMI -> ; [587:56]
5824 | |--EXPR -> EXPR [588:32]
5825 | | `--METHOD_CALL -> ( [588:32]
5826 | | |--DOT -> . [588:19]
5827 | | | |--IDENT -> checkConfig [588:8]
5828 | | | `--IDENT -> addAttribute [588:20]
5829 | | |--ELIST -> ELIST [588:33]
5830 | | | |--EXPR -> EXPR [588:33]
5831 | | | | `--STRING_LITERAL -> "basicOffset" [588:33]
5832 | | | |--COMMA -> , [588:46]
5833 | | | `--EXPR -> EXPR [588:48]
5834 | | | `--STRING_LITERAL -> "4" [588:48]
5835 | | `--RPAREN -> ) [588:51]
5836 | |--SEMI -> ; [588:52]
5837 | |--EXPR -> EXPR [589:32]
5838 | | `--METHOD_CALL -> ( [589:32]
5839 | | |--DOT -> . [589:19]
5840 | | | |--IDENT -> checkConfig [589:8]
5841 | | | `--IDENT -> addAttribute [589:20]
5842 | | |--ELIST -> ELIST [589:33]
5843 | | | |--EXPR -> EXPR [589:33]
5844 | | | | `--STRING_LITERAL -> "braceAdjustment" [589:33]
5845 | | | |--COMMA -> , [589:50]
5846 | | | `--EXPR -> EXPR [589:52]
5847 | | | `--STRING_LITERAL -> "0" [589:52]
5848 | | `--RPAREN -> ) [589:55]
5849 | |--SEMI -> ; [589:56]
5850 | |--EXPR -> EXPR [590:32]
5851 | | `--METHOD_CALL -> ( [590:32]
5852 | | |--DOT -> . [590:19]
5853 | | | |--IDENT -> checkConfig [590:8]
5854 | | | `--IDENT -> addAttribute [590:20]
5855 | | |--ELIST -> ELIST [590:33]
5856 | | | |--EXPR -> EXPR [590:33]
5857 | | | | `--STRING_LITERAL -> "caseIndent" [590:33]
5858 | | | |--COMMA -> , [590:45]
5859 | | | `--EXPR -> EXPR [590:47]
5860 | | | `--STRING_LITERAL -> "4" [590:47]
5861 | | `--RPAREN -> ) [590:50]
5862 | |--SEMI -> ; [590:51]
5863 | |--EXPR -> EXPR [592:32]
5864 | | `--METHOD_CALL -> ( [592:32]
5865 | | |--DOT -> . [592:19]
5866 | | | |--IDENT -> checkConfig [592:8]
5867 | | | `--IDENT -> addAttribute [592:20]
5868 | | |--ELIST -> ELIST [592:33]
5869 | | | |--EXPR -> EXPR [592:33]
5870 | | | | `--STRING_LITERAL -> "forceStrictCondition" [592:33]
5871 | | | |--COMMA -> , [592:55]
5872 | | | `--EXPR -> EXPR [592:57]
5873 | | | `--STRING_LITERAL -> "false" [592:57]
5874 | | `--RPAREN -> ) [592:64]
5875 | |--SEMI -> ; [592:65]
5876 | |--EXPR -> EXPR [593:32]
5877 | | `--METHOD_CALL -> ( [593:32]
5878 | | |--DOT -> . [593:19]
5879 | | | |--IDENT -> checkConfig [593:8]
5880 | | | `--IDENT -> addAttribute [593:20]
5881 | | |--ELIST -> ELIST [593:33]
5882 | | | |--EXPR -> EXPR [593:33]
5883 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [593:33]
5884 | | | |--COMMA -> , [593:58]
5885 | | | `--EXPR -> EXPR [593:60]
5886 | | | `--STRING_LITERAL -> "9" [593:60]
5887 | | `--RPAREN -> ) [593:63]
5888 | |--SEMI -> ; [593:64]
5889 | |--EXPR -> EXPR [594:32]
5890 | | `--METHOD_CALL -> ( [594:32]
5891 | | |--DOT -> . [594:19]
5892 | | | |--IDENT -> checkConfig [594:8]
5893 | | | `--IDENT -> addAttribute [594:20]
5894 | | |--ELIST -> ELIST [594:33]
5895 | | | |--EXPR -> EXPR [594:33]
5896 | | | | `--STRING_LITERAL -> "tabWidth" [594:33]
5897 | | | |--COMMA -> , [594:43]
5898 | | | `--EXPR -> EXPR [594:45]
5899 | | | `--STRING_LITERAL -> "4" [594:45]
5900 | | `--RPAREN -> ) [594:48]
5901 | |--SEMI -> ; [594:49]
5902 | |--EXPR -> EXPR [595:32]
5903 | | `--METHOD_CALL -> ( [595:32]
5904 | | |--DOT -> . [595:19]
5905 | | | |--IDENT -> checkConfig [595:8]
5906 | | | `--IDENT -> addAttribute [595:20]
5907 | | |--ELIST -> ELIST [595:33]
5908 | | | |--EXPR -> EXPR [595:33]
5909 | | | | `--STRING_LITERAL -> "throwsIndent" [595:33]
5910 | | | |--COMMA -> , [595:47]
5911 | | | `--EXPR -> EXPR [595:49]
5912 | | | `--STRING_LITERAL -> "4" [595:49]
5913 | | `--RPAREN -> ) [595:52]
5914 | |--SEMI -> ; [595:53]
5915 | |--VARIABLE_DEF -> VARIABLE_DEF [596:8]
5916 | | |--MODIFIERS -> MODIFIERS [596:8]
5917 | | | `--FINAL -> final [596:8]
5918 | | |--TYPE -> TYPE [596:14]
5919 | | | `--IDENT -> String [596:14]
5920 | | |--IDENT -> fileName [596:21]
5921 | | `--ASSIGN -> = [596:30]
5922 | | `--EXPR -> EXPR [596:39]
5923 | | `--METHOD_CALL -> ( [596:39]
5924 | | |--IDENT -> getPath [596:32]
5925 | | |--ELIST -> ELIST [596:40]
5926 | | | `--EXPR -> EXPR [596:40]
5927 | | | `--STRING_LITERAL -> "InputIndentationOddLineWrappingAndArrayInit.java" [596:40]
5928 | | `--RPAREN -> ) [596:90]
5929 | |--SEMI -> ; [596:91]
5930 | |--VARIABLE_DEF -> VARIABLE_DEF [597:8]
5931 | | |--MODIFIERS -> MODIFIERS [597:8]
5932 | | | `--FINAL -> final [597:8]
5933 | | |--TYPE -> TYPE [597:20]
5934 | | | `--ARRAY_DECLARATOR -> [ [597:20]
5935 | | | |--IDENT -> String [597:14]
5936 | | | `--RBRACK -> ] [597:21]
5937 | | |--IDENT -> expected [597:23]
5938 | | `--ASSIGN -> = [597:32]
5939 | | `--ARRAY_INIT -> { [597:34]
5940 | | |--EXPR -> EXPR [598:22]
5941 | | | `--PLUS -> + [598:22]
5942 | | | |--STRING_LITERAL -> "25:17: " [598:12]
5943 | | | `--METHOD_CALL -> ( [598:39]
5944 | | | |--IDENT -> getCheckMessage [598:24]
5945 | | | |--ELIST -> ELIST [598:40]
5946 | | | | |--EXPR -> EXPR [598:40]
5947 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [598:40]
5948 | | | | |--COMMA -> , [598:61]
5949 | | | | |--EXPR -> EXPR [598:63]
5950 | | | | | `--STRING_LITERAL -> "annotation array initialization" [598:63]
5951 | | | | |--COMMA -> , [598:96]
5952 | | | | |--EXPR -> EXPR [599:20]
5953 | | | | | `--NUM_INT -> 16 [599:20]
5954 | | | | |--COMMA -> , [599:22]
5955 | | | | `--EXPR -> EXPR [599:24]
5956 | | | | `--STRING_LITERAL -> "11, 17, 47, 54" [599:24]
5957 | | | `--RPAREN -> ) [599:40]
5958 | | |--COMMA -> , [599:41]
5959 | | `--RCURLY -> } [600:8]
5960 | |--SEMI -> ; [600:9]
5961 | |--EXPR -> EXPR [601:19]
5962 | | `--METHOD_CALL -> ( [601:19]
5963 | | |--IDENT -> verifyWarns [601:8]
5964 | | |--ELIST -> ELIST [601:20]
5965 | | | |--EXPR -> EXPR [601:20]
5966 | | | | `--IDENT -> checkConfig [601:20]
5967 | | | |--COMMA -> , [601:31]
5968 | | | |--EXPR -> EXPR [601:33]
5969 | | | | `--IDENT -> fileName [601:33]
5970 | | | |--COMMA -> , [601:41]
5971 | | | `--EXPR -> EXPR [601:43]
5972 | | | `--IDENT -> expected [601:43]
5973 | | `--RPAREN -> ) [601:51]
5974 | |--SEMI -> ; [601:52]
5975 | `--RCURLY -> } [602:4]
5976 |--METHOD_DEF -> METHOD_DEF [604:4]
5977 | |--MODIFIERS -> MODIFIERS [604:4]
5978 | | |--ANNOTATION -> ANNOTATION [604:4]
5979 | | | |--AT -> @ [604:4]
5980 | | | `--IDENT -> Test [604:5]
5981 | | `--LITERAL_PUBLIC -> public [605:4]
5982 | |--TYPE -> TYPE [605:11]
5983 | | `--LITERAL_VOID -> void [605:11]
5984 | |--IDENT -> testZeroAnnotationArrayInit [605:16]
5985 | |--LPAREN -> ( [605:43]
5986 | |--PARAMETERS -> PARAMETERS [605:44]
5987 | |--RPAREN -> ) [605:44]
5988 | |--LITERAL_THROWS -> throws [606:12]
5989 | | `--IDENT -> Exception [606:19]
5990 | `--SLIST -> { [606:29]
5991 | |--VARIABLE_DEF -> VARIABLE_DEF [607:8]
5992 | | |--MODIFIERS -> MODIFIERS [607:8]
5993 | | | `--FINAL -> final [607:8]
5994 | | |--TYPE -> TYPE [607:14]
5995 | | | `--IDENT -> DefaultConfiguration [607:14]
5996 | | |--IDENT -> checkConfig [607:35]
5997 | | `--ASSIGN -> = [607:47]
5998 | | `--EXPR -> EXPR [607:67]
5999 | | `--METHOD_CALL -> ( [607:67]
6000 | | |--IDENT -> createModuleConfig [607:49]
6001 | | |--ELIST -> ELIST [607:84]
6002 | | | `--EXPR -> EXPR [607:84]
6003 | | | `--DOT -> . [607:84]
6004 | | | |--IDENT -> IndentationCheck [607:68]
6005 | | | `--LITERAL_CLASS -> class [607:85]
6006 | | `--RPAREN -> ) [607:90]
6007 | |--SEMI -> ; [607:91]
6008 | |--EXPR -> EXPR [609:32]
6009 | | `--METHOD_CALL -> ( [609:32]
6010 | | |--DOT -> . [609:19]
6011 | | | |--IDENT -> checkConfig [609:8]
6012 | | | `--IDENT -> addAttribute [609:20]
6013 | | |--ELIST -> ELIST [609:33]
6014 | | | |--EXPR -> EXPR [609:33]
6015 | | | | `--STRING_LITERAL -> "arrayInitIndent" [609:33]
6016 | | | |--COMMA -> , [609:50]
6017 | | | `--EXPR -> EXPR [609:52]
6018 | | | `--STRING_LITERAL -> "0" [609:52]
6019 | | `--RPAREN -> ) [609:55]
6020 | |--SEMI -> ; [609:56]
6021 | |--EXPR -> EXPR [610:32]
6022 | | `--METHOD_CALL -> ( [610:32]
6023 | | |--DOT -> . [610:19]
6024 | | | |--IDENT -> checkConfig [610:8]
6025 | | | `--IDENT -> addAttribute [610:20]
6026 | | |--ELIST -> ELIST [610:33]
6027 | | | |--EXPR -> EXPR [610:33]
6028 | | | | `--STRING_LITERAL -> "basicOffset" [610:33]
6029 | | | |--COMMA -> , [610:46]
6030 | | | `--EXPR -> EXPR [610:48]
6031 | | | `--STRING_LITERAL -> "4" [610:48]
6032 | | `--RPAREN -> ) [610:51]
6033 | |--SEMI -> ; [610:52]
6034 | |--EXPR -> EXPR [611:32]
6035 | | `--METHOD_CALL -> ( [611:32]
6036 | | |--DOT -> . [611:19]
6037 | | | |--IDENT -> checkConfig [611:8]
6038 | | | `--IDENT -> addAttribute [611:20]
6039 | | |--ELIST -> ELIST [611:33]
6040 | | | |--EXPR -> EXPR [611:33]
6041 | | | | `--STRING_LITERAL -> "braceAdjustment" [611:33]
6042 | | | |--COMMA -> , [611:50]
6043 | | | `--EXPR -> EXPR [611:52]
6044 | | | `--STRING_LITERAL -> "0" [611:52]
6045 | | `--RPAREN -> ) [611:55]
6046 | |--SEMI -> ; [611:56]
6047 | |--EXPR -> EXPR [612:32]
6048 | | `--METHOD_CALL -> ( [612:32]
6049 | | |--DOT -> . [612:19]
6050 | | | |--IDENT -> checkConfig [612:8]
6051 | | | `--IDENT -> addAttribute [612:20]
6052 | | |--ELIST -> ELIST [612:33]
6053 | | | |--EXPR -> EXPR [612:33]
6054 | | | | `--STRING_LITERAL -> "caseIndent" [612:33]
6055 | | | |--COMMA -> , [612:45]
6056 | | | `--EXPR -> EXPR [612:47]
6057 | | | `--STRING_LITERAL -> "4" [612:47]
6058 | | `--RPAREN -> ) [612:50]
6059 | |--SEMI -> ; [612:51]
6060 | |--EXPR -> EXPR [613:32]
6061 | | `--METHOD_CALL -> ( [613:32]
6062 | | |--DOT -> . [613:19]
6063 | | | |--IDENT -> checkConfig [613:8]
6064 | | | `--IDENT -> addAttribute [613:20]
6065 | | |--ELIST -> ELIST [613:33]
6066 | | | |--EXPR -> EXPR [613:33]
6067 | | | | `--STRING_LITERAL -> "forceStrictCondition" [613:33]
6068 | | | |--COMMA -> , [613:55]
6069 | | | `--EXPR -> EXPR [613:57]
6070 | | | `--STRING_LITERAL -> "false" [613:57]
6071 | | `--RPAREN -> ) [613:64]
6072 | |--SEMI -> ; [613:65]
6073 | |--EXPR -> EXPR [614:32]
6074 | | `--METHOD_CALL -> ( [614:32]
6075 | | |--DOT -> . [614:19]
6076 | | | |--IDENT -> checkConfig [614:8]
6077 | | | `--IDENT -> addAttribute [614:20]
6078 | | |--ELIST -> ELIST [614:33]
6079 | | | |--EXPR -> EXPR [614:33]
6080 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [614:33]
6081 | | | |--COMMA -> , [614:58]
6082 | | | `--EXPR -> EXPR [614:60]
6083 | | | `--STRING_LITERAL -> "4" [614:60]
6084 | | `--RPAREN -> ) [614:63]
6085 | |--SEMI -> ; [614:64]
6086 | |--EXPR -> EXPR [615:32]
6087 | | `--METHOD_CALL -> ( [615:32]
6088 | | |--DOT -> . [615:19]
6089 | | | |--IDENT -> checkConfig [615:8]
6090 | | | `--IDENT -> addAttribute [615:20]
6091 | | |--ELIST -> ELIST [615:33]
6092 | | | |--EXPR -> EXPR [615:33]
6093 | | | | `--STRING_LITERAL -> "tabWidth" [615:33]
6094 | | | |--COMMA -> , [615:43]
6095 | | | `--EXPR -> EXPR [615:45]
6096 | | | `--STRING_LITERAL -> "4" [615:45]
6097 | | `--RPAREN -> ) [615:48]
6098 | |--SEMI -> ; [615:49]
6099 | |--EXPR -> EXPR [616:32]
6100 | | `--METHOD_CALL -> ( [616:32]
6101 | | |--DOT -> . [616:19]
6102 | | | |--IDENT -> checkConfig [616:8]
6103 | | | `--IDENT -> addAttribute [616:20]
6104 | | |--ELIST -> ELIST [616:33]
6105 | | | |--EXPR -> EXPR [616:33]
6106 | | | | `--STRING_LITERAL -> "throwsIndent" [616:33]
6107 | | | |--COMMA -> , [616:47]
6108 | | | `--EXPR -> EXPR [616:49]
6109 | | | `--STRING_LITERAL -> "4" [616:49]
6110 | | `--RPAREN -> ) [616:52]
6111 | |--SEMI -> ; [616:53]
6112 | |--VARIABLE_DEF -> VARIABLE_DEF [617:8]
6113 | | |--MODIFIERS -> MODIFIERS [617:8]
6114 | | | `--FINAL -> final [617:8]
6115 | | |--TYPE -> TYPE [617:14]
6116 | | | `--IDENT -> String [617:14]
6117 | | |--IDENT -> fileName [617:21]
6118 | | `--ASSIGN -> = [617:30]
6119 | | `--EXPR -> EXPR [617:39]
6120 | | `--METHOD_CALL -> ( [617:39]
6121 | | |--IDENT -> getPath [617:32]
6122 | | |--ELIST -> ELIST [617:40]
6123 | | | `--EXPR -> EXPR [617:40]
6124 | | | `--STRING_LITERAL -> "InputIndentationZeroArrayInit.java" [617:40]
6125 | | `--RPAREN -> ) [617:76]
6126 | |--SEMI -> ; [617:77]
6127 | |--VARIABLE_DEF -> VARIABLE_DEF [619:8]
6128 | | |--MODIFIERS -> MODIFIERS [619:8]
6129 | | | `--FINAL -> final [619:8]
6130 | | |--TYPE -> TYPE [619:20]
6131 | | | `--ARRAY_DECLARATOR -> [ [619:20]
6132 | | | |--IDENT -> String [619:14]
6133 | | | `--RBRACK -> ] [619:21]
6134 | | |--IDENT -> expected [619:23]
6135 | | `--ASSIGN -> = [619:32]
6136 | | `--ARRAY_INIT -> { [619:34]
6137 | | |--EXPR -> EXPR [620:22]
6138 | | | `--PLUS -> + [620:22]
6139 | | | |--STRING_LITERAL -> "22:12: " [620:12]
6140 | | | `--METHOD_CALL -> ( [620:39]
6141 | | | |--IDENT -> getCheckMessage [620:24]
6142 | | | |--ELIST -> ELIST [620:40]
6143 | | | | |--EXPR -> EXPR [620:40]
6144 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [620:40]
6145 | | | | |--COMMA -> , [620:61]
6146 | | | | |--EXPR -> EXPR [620:63]
6147 | | | | | `--STRING_LITERAL -> "annotation array initialization" [620:63]
6148 | | | | |--COMMA -> , [620:96]
6149 | | | | |--EXPR -> EXPR [621:20]
6150 | | | | | `--NUM_INT -> 11 [621:20]
6151 | | | | |--COMMA -> , [621:22]
6152 | | | | `--EXPR -> EXPR [621:24]
6153 | | | | `--STRING_LITERAL -> "8, 12, 35, 37" [621:24]
6154 | | | `--RPAREN -> ) [621:39]
6155 | | |--COMMA -> , [621:40]
6156 | | `--RCURLY -> } [622:8]
6157 | |--SEMI -> ; [622:9]
6158 | |--EXPR -> EXPR [623:19]
6159 | | `--METHOD_CALL -> ( [623:19]
6160 | | |--IDENT -> verifyWarns [623:8]
6161 | | |--ELIST -> ELIST [623:20]
6162 | | | |--EXPR -> EXPR [623:20]
6163 | | | | `--IDENT -> checkConfig [623:20]
6164 | | | |--COMMA -> , [623:31]
6165 | | | |--EXPR -> EXPR [623:33]
6166 | | | | `--IDENT -> fileName [623:33]
6167 | | | |--COMMA -> , [623:41]
6168 | | | `--EXPR -> EXPR [623:43]
6169 | | | `--IDENT -> expected [623:43]
6170 | | `--RPAREN -> ) [623:51]
6171 | |--SEMI -> ; [623:52]
6172 | `--RCURLY -> } [624:4]
6173 |--METHOD_DEF -> METHOD_DEF [626:4]
6174 | |--MODIFIERS -> MODIFIERS [626:4]
6175 | | |--ANNOTATION -> ANNOTATION [626:4]
6176 | | | |--AT -> @ [626:4]
6177 | | | `--IDENT -> Test [626:5]
6178 | | `--LITERAL_PUBLIC -> public [627:4]
6179 | |--TYPE -> TYPE [627:11]
6180 | | `--LITERAL_VOID -> void [627:11]
6181 | |--IDENT -> testAnnotationArrayInitGoodCase [627:16]
6182 | |--LPAREN -> ( [627:47]
6183 | |--PARAMETERS -> PARAMETERS [627:48]
6184 | |--RPAREN -> ) [627:48]
6185 | |--LITERAL_THROWS -> throws [628:12]
6186 | | `--IDENT -> Exception [628:19]
6187 | `--SLIST -> { [628:29]
6188 | |--VARIABLE_DEF -> VARIABLE_DEF [629:8]
6189 | | |--MODIFIERS -> MODIFIERS [629:8]
6190 | | | `--FINAL -> final [629:8]
6191 | | |--TYPE -> TYPE [629:14]
6192 | | | `--IDENT -> DefaultConfiguration [629:14]
6193 | | |--IDENT -> checkConfig [629:35]
6194 | | `--ASSIGN -> = [629:47]
6195 | | `--EXPR -> EXPR [629:67]
6196 | | `--METHOD_CALL -> ( [629:67]
6197 | | |--IDENT -> createModuleConfig [629:49]
6198 | | |--ELIST -> ELIST [629:84]
6199 | | | `--EXPR -> EXPR [629:84]
6200 | | | `--DOT -> . [629:84]
6201 | | | |--IDENT -> IndentationCheck [629:68]
6202 | | | `--LITERAL_CLASS -> class [629:85]
6203 | | `--RPAREN -> ) [629:90]
6204 | |--SEMI -> ; [629:91]
6205 | |--EXPR -> EXPR [631:32]
6206 | | `--METHOD_CALL -> ( [631:32]
6207 | | |--DOT -> . [631:19]
6208 | | | |--IDENT -> checkConfig [631:8]
6209 | | | `--IDENT -> addAttribute [631:20]
6210 | | |--ELIST -> ELIST [631:33]
6211 | | | |--EXPR -> EXPR [631:33]
6212 | | | | `--STRING_LITERAL -> "arrayInitIndent" [631:33]
6213 | | | |--COMMA -> , [631:50]
6214 | | | `--EXPR -> EXPR [631:52]
6215 | | | `--STRING_LITERAL -> "4" [631:52]
6216 | | `--RPAREN -> ) [631:55]
6217 | |--SEMI -> ; [631:56]
6218 | |--EXPR -> EXPR [632:32]
6219 | | `--METHOD_CALL -> ( [632:32]
6220 | | |--DOT -> . [632:19]
6221 | | | |--IDENT -> checkConfig [632:8]
6222 | | | `--IDENT -> addAttribute [632:20]
6223 | | |--ELIST -> ELIST [632:33]
6224 | | | |--EXPR -> EXPR [632:33]
6225 | | | | `--STRING_LITERAL -> "basicOffset" [632:33]
6226 | | | |--COMMA -> , [632:46]
6227 | | | `--EXPR -> EXPR [632:48]
6228 | | | `--STRING_LITERAL -> "4" [632:48]
6229 | | `--RPAREN -> ) [632:51]
6230 | |--SEMI -> ; [632:52]
6231 | |--EXPR -> EXPR [633:32]
6232 | | `--METHOD_CALL -> ( [633:32]
6233 | | |--DOT -> . [633:19]
6234 | | | |--IDENT -> checkConfig [633:8]
6235 | | | `--IDENT -> addAttribute [633:20]
6236 | | |--ELIST -> ELIST [633:33]
6237 | | | |--EXPR -> EXPR [633:33]
6238 | | | | `--STRING_LITERAL -> "braceAdjustment" [633:33]
6239 | | | |--COMMA -> , [633:50]
6240 | | | `--EXPR -> EXPR [633:52]
6241 | | | `--STRING_LITERAL -> "0" [633:52]
6242 | | `--RPAREN -> ) [633:55]
6243 | |--SEMI -> ; [633:56]
6244 | |--EXPR -> EXPR [634:32]
6245 | | `--METHOD_CALL -> ( [634:32]
6246 | | |--DOT -> . [634:19]
6247 | | | |--IDENT -> checkConfig [634:8]
6248 | | | `--IDENT -> addAttribute [634:20]
6249 | | |--ELIST -> ELIST [634:33]
6250 | | | |--EXPR -> EXPR [634:33]
6251 | | | | `--STRING_LITERAL -> "caseIndent" [634:33]
6252 | | | |--COMMA -> , [634:45]
6253 | | | `--EXPR -> EXPR [634:47]
6254 | | | `--STRING_LITERAL -> "4" [634:47]
6255 | | `--RPAREN -> ) [634:50]
6256 | |--SEMI -> ; [634:51]
6257 | |--EXPR -> EXPR [635:32]
6258 | | `--METHOD_CALL -> ( [635:32]
6259 | | |--DOT -> . [635:19]
6260 | | | |--IDENT -> checkConfig [635:8]
6261 | | | `--IDENT -> addAttribute [635:20]
6262 | | |--ELIST -> ELIST [635:33]
6263 | | | |--EXPR -> EXPR [635:33]
6264 | | | | `--STRING_LITERAL -> "forceStrictCondition" [635:33]
6265 | | | |--COMMA -> , [635:55]
6266 | | | `--EXPR -> EXPR [635:57]
6267 | | | `--STRING_LITERAL -> "false" [635:57]
6268 | | `--RPAREN -> ) [635:64]
6269 | |--SEMI -> ; [635:65]
6270 | |--EXPR -> EXPR [636:32]
6271 | | `--METHOD_CALL -> ( [636:32]
6272 | | |--DOT -> . [636:19]
6273 | | | |--IDENT -> checkConfig [636:8]
6274 | | | `--IDENT -> addAttribute [636:20]
6275 | | |--ELIST -> ELIST [636:33]
6276 | | | |--EXPR -> EXPR [636:33]
6277 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [636:33]
6278 | | | |--COMMA -> , [636:58]
6279 | | | `--EXPR -> EXPR [636:60]
6280 | | | `--STRING_LITERAL -> "4" [636:60]
6281 | | `--RPAREN -> ) [636:63]
6282 | |--SEMI -> ; [636:64]
6283 | |--EXPR -> EXPR [637:32]
6284 | | `--METHOD_CALL -> ( [637:32]
6285 | | |--DOT -> . [637:19]
6286 | | | |--IDENT -> checkConfig [637:8]
6287 | | | `--IDENT -> addAttribute [637:20]
6288 | | |--ELIST -> ELIST [637:33]
6289 | | | |--EXPR -> EXPR [637:33]
6290 | | | | `--STRING_LITERAL -> "tabWidth" [637:33]
6291 | | | |--COMMA -> , [637:43]
6292 | | | `--EXPR -> EXPR [637:45]
6293 | | | `--STRING_LITERAL -> "4" [637:45]
6294 | | `--RPAREN -> ) [637:48]
6295 | |--SEMI -> ; [637:49]
6296 | |--EXPR -> EXPR [638:32]
6297 | | `--METHOD_CALL -> ( [638:32]
6298 | | |--DOT -> . [638:19]
6299 | | | |--IDENT -> checkConfig [638:8]
6300 | | | `--IDENT -> addAttribute [638:20]
6301 | | |--ELIST -> ELIST [638:33]
6302 | | | |--EXPR -> EXPR [638:33]
6303 | | | | `--STRING_LITERAL -> "throwsIndent" [638:33]
6304 | | | |--COMMA -> , [638:47]
6305 | | | `--EXPR -> EXPR [638:49]
6306 | | | `--STRING_LITERAL -> "4" [638:49]
6307 | | `--RPAREN -> ) [638:52]
6308 | |--SEMI -> ; [638:53]
6309 | |--VARIABLE_DEF -> VARIABLE_DEF [639:8]
6310 | | |--MODIFIERS -> MODIFIERS [639:8]
6311 | | | `--FINAL -> final [639:8]
6312 | | |--TYPE -> TYPE [639:14]
6313 | | | `--IDENT -> String [639:14]
6314 | | |--IDENT -> fileName [639:21]
6315 | | `--ASSIGN -> = [639:30]
6316 | | `--EXPR -> EXPR [639:39]
6317 | | `--METHOD_CALL -> ( [639:39]
6318 | | |--IDENT -> getPath [639:32]
6319 | | |--ELIST -> ELIST [639:40]
6320 | | | `--EXPR -> EXPR [639:40]
6321 | | | `--STRING_LITERAL -> "InputIndentationAnnotationArrayInitGood.java" [639:40]
6322 | | `--RPAREN -> ) [639:86]
6323 | |--SEMI -> ; [639:87]
6324 | |--VARIABLE_DEF -> VARIABLE_DEF [640:8]
6325 | | |--MODIFIERS -> MODIFIERS [640:8]
6326 | | | `--FINAL -> final [640:8]
6327 | | |--TYPE -> TYPE [640:20]
6328 | | | `--ARRAY_DECLARATOR -> [ [640:20]
6329 | | | |--IDENT -> String [640:14]
6330 | | | `--RBRACK -> ] [640:21]
6331 | | |--IDENT -> expected [640:23]
6332 | | `--ASSIGN -> = [640:32]
6333 | | `--EXPR -> EXPR [640:44]
6334 | | `--DOT -> . [640:44]
6335 | | |--IDENT -> CommonUtil [640:34]
6336 | | `--IDENT -> EMPTY_STRING_ARRAY [640:45]
6337 | |--SEMI -> ; [640:63]
6338 | |--EXPR -> EXPR [641:19]
6339 | | `--METHOD_CALL -> ( [641:19]
6340 | | |--IDENT -> verifyWarns [641:8]
6341 | | |--ELIST -> ELIST [641:20]
6342 | | | |--EXPR -> EXPR [641:20]
6343 | | | | `--IDENT -> checkConfig [641:20]
6344 | | | |--COMMA -> , [641:31]
6345 | | | |--EXPR -> EXPR [641:33]
6346 | | | | `--IDENT -> fileName [641:33]
6347 | | | |--COMMA -> , [641:41]
6348 | | | `--EXPR -> EXPR [641:43]
6349 | | | `--IDENT -> expected [641:43]
6350 | | `--RPAREN -> ) [641:51]
6351 | |--SEMI -> ; [641:52]
6352 | `--RCURLY -> } [642:4]
6353 |--METHOD_DEF -> METHOD_DEF [644:4]
6354 | |--MODIFIERS -> MODIFIERS [644:4]
6355 | | |--ANNOTATION -> ANNOTATION [644:4]
6356 | | | |--AT -> @ [644:4]
6357 | | | `--IDENT -> Test [644:5]
6358 | | `--LITERAL_PUBLIC -> public [645:4]
6359 | |--TYPE -> TYPE [645:11]
6360 | | `--LITERAL_VOID -> void [645:11]
6361 | |--IDENT -> testAnnotationArrayInitGoodCaseTwo [645:16]
6362 | |--LPAREN -> ( [645:50]
6363 | |--PARAMETERS -> PARAMETERS [645:51]
6364 | |--RPAREN -> ) [645:51]
6365 | |--LITERAL_THROWS -> throws [646:12]
6366 | | `--IDENT -> Exception [646:19]
6367 | `--SLIST -> { [646:29]
6368 | |--VARIABLE_DEF -> VARIABLE_DEF [647:8]
6369 | | |--MODIFIERS -> MODIFIERS [647:8]
6370 | | | `--FINAL -> final [647:8]
6371 | | |--TYPE -> TYPE [647:14]
6372 | | | `--IDENT -> DefaultConfiguration [647:14]
6373 | | |--IDENT -> checkConfig [647:35]
6374 | | `--ASSIGN -> = [647:47]
6375 | | `--EXPR -> EXPR [647:67]
6376 | | `--METHOD_CALL -> ( [647:67]
6377 | | |--IDENT -> createModuleConfig [647:49]
6378 | | |--ELIST -> ELIST [647:84]
6379 | | | `--EXPR -> EXPR [647:84]
6380 | | | `--DOT -> . [647:84]
6381 | | | |--IDENT -> IndentationCheck [647:68]
6382 | | | `--LITERAL_CLASS -> class [647:85]
6383 | | `--RPAREN -> ) [647:90]
6384 | |--SEMI -> ; [647:91]
6385 | |--EXPR -> EXPR [649:32]
6386 | | `--METHOD_CALL -> ( [649:32]
6387 | | |--DOT -> . [649:19]
6388 | | | |--IDENT -> checkConfig [649:8]
6389 | | | `--IDENT -> addAttribute [649:20]
6390 | | |--ELIST -> ELIST [649:33]
6391 | | | |--EXPR -> EXPR [649:33]
6392 | | | | `--STRING_LITERAL -> "arrayInitIndent" [649:33]
6393 | | | |--COMMA -> , [649:50]
6394 | | | `--EXPR -> EXPR [649:52]
6395 | | | `--STRING_LITERAL -> "4" [649:52]
6396 | | `--RPAREN -> ) [649:55]
6397 | |--SEMI -> ; [649:56]
6398 | |--EXPR -> EXPR [650:32]
6399 | | `--METHOD_CALL -> ( [650:32]
6400 | | |--DOT -> . [650:19]
6401 | | | |--IDENT -> checkConfig [650:8]
6402 | | | `--IDENT -> addAttribute [650:20]
6403 | | |--ELIST -> ELIST [650:33]
6404 | | | |--EXPR -> EXPR [650:33]
6405 | | | | `--STRING_LITERAL -> "basicOffset" [650:33]
6406 | | | |--COMMA -> , [650:46]
6407 | | | `--EXPR -> EXPR [650:48]
6408 | | | `--STRING_LITERAL -> "4" [650:48]
6409 | | `--RPAREN -> ) [650:51]
6410 | |--SEMI -> ; [650:52]
6411 | |--EXPR -> EXPR [651:32]
6412 | | `--METHOD_CALL -> ( [651:32]
6413 | | |--DOT -> . [651:19]
6414 | | | |--IDENT -> checkConfig [651:8]
6415 | | | `--IDENT -> addAttribute [651:20]
6416 | | |--ELIST -> ELIST [651:33]
6417 | | | |--EXPR -> EXPR [651:33]
6418 | | | | `--STRING_LITERAL -> "braceAdjustment" [651:33]
6419 | | | |--COMMA -> , [651:50]
6420 | | | `--EXPR -> EXPR [651:52]
6421 | | | `--STRING_LITERAL -> "2" [651:52]
6422 | | `--RPAREN -> ) [651:55]
6423 | |--SEMI -> ; [651:56]
6424 | |--EXPR -> EXPR [652:32]
6425 | | `--METHOD_CALL -> ( [652:32]
6426 | | |--DOT -> . [652:19]
6427 | | | |--IDENT -> checkConfig [652:8]
6428 | | | `--IDENT -> addAttribute [652:20]
6429 | | |--ELIST -> ELIST [652:33]
6430 | | | |--EXPR -> EXPR [652:33]
6431 | | | | `--STRING_LITERAL -> "caseIndent" [652:33]
6432 | | | |--COMMA -> , [652:45]
6433 | | | `--EXPR -> EXPR [652:47]
6434 | | | `--STRING_LITERAL -> "4" [652:47]
6435 | | `--RPAREN -> ) [652:50]
6436 | |--SEMI -> ; [652:51]
6437 | |--EXPR -> EXPR [653:32]
6438 | | `--METHOD_CALL -> ( [653:32]
6439 | | |--DOT -> . [653:19]
6440 | | | |--IDENT -> checkConfig [653:8]
6441 | | | `--IDENT -> addAttribute [653:20]
6442 | | |--ELIST -> ELIST [653:33]
6443 | | | |--EXPR -> EXPR [653:33]
6444 | | | | `--STRING_LITERAL -> "forceStrictCondition" [653:33]
6445 | | | |--COMMA -> , [653:55]
6446 | | | `--EXPR -> EXPR [653:57]
6447 | | | `--STRING_LITERAL -> "false" [653:57]
6448 | | `--RPAREN -> ) [653:64]
6449 | |--SEMI -> ; [653:65]
6450 | |--EXPR -> EXPR [654:32]
6451 | | `--METHOD_CALL -> ( [654:32]
6452 | | |--DOT -> . [654:19]
6453 | | | |--IDENT -> checkConfig [654:8]
6454 | | | `--IDENT -> addAttribute [654:20]
6455 | | |--ELIST -> ELIST [654:33]
6456 | | | |--EXPR -> EXPR [654:33]
6457 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [654:33]
6458 | | | |--COMMA -> , [654:58]
6459 | | | `--EXPR -> EXPR [654:60]
6460 | | | `--STRING_LITERAL -> "4" [654:60]
6461 | | `--RPAREN -> ) [654:63]
6462 | |--SEMI -> ; [654:64]
6463 | |--EXPR -> EXPR [655:32]
6464 | | `--METHOD_CALL -> ( [655:32]
6465 | | |--DOT -> . [655:19]
6466 | | | |--IDENT -> checkConfig [655:8]
6467 | | | `--IDENT -> addAttribute [655:20]
6468 | | |--ELIST -> ELIST [655:33]
6469 | | | |--EXPR -> EXPR [655:33]
6470 | | | | `--STRING_LITERAL -> "tabWidth" [655:33]
6471 | | | |--COMMA -> , [655:43]
6472 | | | `--EXPR -> EXPR [655:45]
6473 | | | `--STRING_LITERAL -> "4" [655:45]
6474 | | `--RPAREN -> ) [655:48]
6475 | |--SEMI -> ; [655:49]
6476 | |--EXPR -> EXPR [656:32]
6477 | | `--METHOD_CALL -> ( [656:32]
6478 | | |--DOT -> . [656:19]
6479 | | | |--IDENT -> checkConfig [656:8]
6480 | | | `--IDENT -> addAttribute [656:20]
6481 | | |--ELIST -> ELIST [656:33]
6482 | | | |--EXPR -> EXPR [656:33]
6483 | | | | `--STRING_LITERAL -> "throwsIndent" [656:33]
6484 | | | |--COMMA -> , [656:47]
6485 | | | `--EXPR -> EXPR [656:49]
6486 | | | `--STRING_LITERAL -> "4" [656:49]
6487 | | `--RPAREN -> ) [656:52]
6488 | |--SEMI -> ; [656:53]
6489 | |--VARIABLE_DEF -> VARIABLE_DEF [657:8]
6490 | | |--MODIFIERS -> MODIFIERS [657:8]
6491 | | | `--FINAL -> final [657:8]
6492 | | |--TYPE -> TYPE [657:14]
6493 | | | `--IDENT -> String [657:14]
6494 | | |--IDENT -> fileName [657:21]
6495 | | `--ASSIGN -> = [657:30]
6496 | | `--EXPR -> EXPR [657:39]
6497 | | `--METHOD_CALL -> ( [657:39]
6498 | | |--IDENT -> getPath [657:32]
6499 | | |--ELIST -> ELIST [657:40]
6500 | | | `--EXPR -> EXPR [657:40]
6501 | | | `--STRING_LITERAL -> "InputIndentationAnnotationArrayInitGood.java" [657:40]
6502 | | `--RPAREN -> ) [657:86]
6503 | |--SEMI -> ; [657:87]
6504 | |--VARIABLE_DEF -> VARIABLE_DEF [658:8]
6505 | | |--MODIFIERS -> MODIFIERS [658:8]
6506 | | | `--FINAL -> final [658:8]
6507 | | |--TYPE -> TYPE [658:20]
6508 | | | `--ARRAY_DECLARATOR -> [ [658:20]
6509 | | | |--IDENT -> String [658:14]
6510 | | | `--RBRACK -> ] [658:21]
6511 | | |--IDENT -> expected [658:23]
6512 | | `--ASSIGN -> = [658:32]
6513 | | `--EXPR -> EXPR [658:44]
6514 | | `--DOT -> . [658:44]
6515 | | |--IDENT -> CommonUtil [658:34]
6516 | | `--IDENT -> EMPTY_STRING_ARRAY [658:45]
6517 | |--SEMI -> ; [658:63]
6518 | |--EXPR -> EXPR [659:19]
6519 | | `--METHOD_CALL -> ( [659:19]
6520 | | |--IDENT -> verifyWarns [659:8]
6521 | | |--ELIST -> ELIST [659:20]
6522 | | | |--EXPR -> EXPR [659:20]
6523 | | | | `--IDENT -> checkConfig [659:20]
6524 | | | |--COMMA -> , [659:31]
6525 | | | |--EXPR -> EXPR [659:33]
6526 | | | | `--IDENT -> fileName [659:33]
6527 | | | |--COMMA -> , [659:41]
6528 | | | `--EXPR -> EXPR [659:43]
6529 | | | `--IDENT -> expected [659:43]
6530 | | `--RPAREN -> ) [659:51]
6531 | |--SEMI -> ; [659:52]
6532 | `--RCURLY -> } [660:4]
6533 |--METHOD_DEF -> METHOD_DEF [662:4]
6534 | |--MODIFIERS -> MODIFIERS [662:4]
6535 | | |--ANNOTATION -> ANNOTATION [662:4]
6536 | | | |--AT -> @ [662:4]
6537 | | | `--IDENT -> Test [662:5]
6538 | | `--LITERAL_PUBLIC -> public [663:4]
6539 | |--TYPE -> TYPE [663:11]
6540 | | `--LITERAL_VOID -> void [663:11]
6541 | |--IDENT -> testInvalidLabel [663:16]
6542 | |--LPAREN -> ( [663:32]
6543 | |--PARAMETERS -> PARAMETERS [663:33]
6544 | |--RPAREN -> ) [663:33]
6545 | |--LITERAL_THROWS -> throws [663:35]
6546 | | `--IDENT -> Exception [663:42]
6547 | `--SLIST -> { [663:52]
6548 | |--VARIABLE_DEF -> VARIABLE_DEF [664:8]
6549 | | |--MODIFIERS -> MODIFIERS [664:8]
6550 | | | `--FINAL -> final [664:8]
6551 | | |--TYPE -> TYPE [664:14]
6552 | | | `--IDENT -> DefaultConfiguration [664:14]
6553 | | |--IDENT -> checkConfig [664:35]
6554 | | `--ASSIGN -> = [664:47]
6555 | | `--EXPR -> EXPR [664:67]
6556 | | `--METHOD_CALL -> ( [664:67]
6557 | | |--IDENT -> createModuleConfig [664:49]
6558 | | |--ELIST -> ELIST [664:84]
6559 | | | `--EXPR -> EXPR [664:84]
6560 | | | `--DOT -> . [664:84]
6561 | | | |--IDENT -> IndentationCheck [664:68]
6562 | | | `--LITERAL_CLASS -> class [664:85]
6563 | | `--RPAREN -> ) [664:90]
6564 | |--SEMI -> ; [664:91]
6565 | |--EXPR -> EXPR [666:32]
6566 | | `--METHOD_CALL -> ( [666:32]
6567 | | |--DOT -> . [666:19]
6568 | | | |--IDENT -> checkConfig [666:8]
6569 | | | `--IDENT -> addAttribute [666:20]
6570 | | |--ELIST -> ELIST [666:33]
6571 | | | |--EXPR -> EXPR [666:33]
6572 | | | | `--STRING_LITERAL -> "arrayInitIndent" [666:33]
6573 | | | |--COMMA -> , [666:50]
6574 | | | `--EXPR -> EXPR [666:52]
6575 | | | `--STRING_LITERAL -> "4" [666:52]
6576 | | `--RPAREN -> ) [666:55]
6577 | |--SEMI -> ; [666:56]
6578 | |--EXPR -> EXPR [667:32]
6579 | | `--METHOD_CALL -> ( [667:32]
6580 | | |--DOT -> . [667:19]
6581 | | | |--IDENT -> checkConfig [667:8]
6582 | | | `--IDENT -> addAttribute [667:20]
6583 | | |--ELIST -> ELIST [667:33]
6584 | | | |--EXPR -> EXPR [667:33]
6585 | | | | `--STRING_LITERAL -> "basicOffset" [667:33]
6586 | | | |--COMMA -> , [667:46]
6587 | | | `--EXPR -> EXPR [667:48]
6588 | | | `--STRING_LITERAL -> "4" [667:48]
6589 | | `--RPAREN -> ) [667:51]
6590 | |--SEMI -> ; [667:52]
6591 | |--EXPR -> EXPR [668:32]
6592 | | `--METHOD_CALL -> ( [668:32]
6593 | | |--DOT -> . [668:19]
6594 | | | |--IDENT -> checkConfig [668:8]
6595 | | | `--IDENT -> addAttribute [668:20]
6596 | | |--ELIST -> ELIST [668:33]
6597 | | | |--EXPR -> EXPR [668:33]
6598 | | | | `--STRING_LITERAL -> "braceAdjustment" [668:33]
6599 | | | |--COMMA -> , [668:50]
6600 | | | `--EXPR -> EXPR [668:52]
6601 | | | `--STRING_LITERAL -> "0" [668:52]
6602 | | `--RPAREN -> ) [668:55]
6603 | |--SEMI -> ; [668:56]
6604 | |--EXPR -> EXPR [669:32]
6605 | | `--METHOD_CALL -> ( [669:32]
6606 | | |--DOT -> . [669:19]
6607 | | | |--IDENT -> checkConfig [669:8]
6608 | | | `--IDENT -> addAttribute [669:20]
6609 | | |--ELIST -> ELIST [669:33]
6610 | | | |--EXPR -> EXPR [669:33]
6611 | | | | `--STRING_LITERAL -> "caseIndent" [669:33]
6612 | | | |--COMMA -> , [669:45]
6613 | | | `--EXPR -> EXPR [669:47]
6614 | | | `--STRING_LITERAL -> "4" [669:47]
6615 | | `--RPAREN -> ) [669:50]
6616 | |--SEMI -> ; [669:51]
6617 | |--EXPR -> EXPR [670:32]
6618 | | `--METHOD_CALL -> ( [670:32]
6619 | | |--DOT -> . [670:19]
6620 | | | |--IDENT -> checkConfig [670:8]
6621 | | | `--IDENT -> addAttribute [670:20]
6622 | | |--ELIST -> ELIST [670:33]
6623 | | | |--EXPR -> EXPR [670:33]
6624 | | | | `--STRING_LITERAL -> "forceStrictCondition" [670:33]
6625 | | | |--COMMA -> , [670:55]
6626 | | | `--EXPR -> EXPR [670:57]
6627 | | | `--STRING_LITERAL -> "false" [670:57]
6628 | | `--RPAREN -> ) [670:64]
6629 | |--SEMI -> ; [670:65]
6630 | |--EXPR -> EXPR [671:32]
6631 | | `--METHOD_CALL -> ( [671:32]
6632 | | |--DOT -> . [671:19]
6633 | | | |--IDENT -> checkConfig [671:8]
6634 | | | `--IDENT -> addAttribute [671:20]
6635 | | |--ELIST -> ELIST [671:33]
6636 | | | |--EXPR -> EXPR [671:33]
6637 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [671:33]
6638 | | | |--COMMA -> , [671:58]
6639 | | | `--EXPR -> EXPR [671:60]
6640 | | | `--STRING_LITERAL -> "4" [671:60]
6641 | | `--RPAREN -> ) [671:63]
6642 | |--SEMI -> ; [671:64]
6643 | |--EXPR -> EXPR [672:32]
6644 | | `--METHOD_CALL -> ( [672:32]
6645 | | |--DOT -> . [672:19]
6646 | | | |--IDENT -> checkConfig [672:8]
6647 | | | `--IDENT -> addAttribute [672:20]
6648 | | |--ELIST -> ELIST [672:33]
6649 | | | |--EXPR -> EXPR [672:33]
6650 | | | | `--STRING_LITERAL -> "tabWidth" [672:33]
6651 | | | |--COMMA -> , [672:43]
6652 | | | `--EXPR -> EXPR [672:45]
6653 | | | `--STRING_LITERAL -> "4" [672:45]
6654 | | `--RPAREN -> ) [672:48]
6655 | |--SEMI -> ; [672:49]
6656 | |--EXPR -> EXPR [673:32]
6657 | | `--METHOD_CALL -> ( [673:32]
6658 | | |--DOT -> . [673:19]
6659 | | | |--IDENT -> checkConfig [673:8]
6660 | | | `--IDENT -> addAttribute [673:20]
6661 | | |--ELIST -> ELIST [673:33]
6662 | | | |--EXPR -> EXPR [673:33]
6663 | | | | `--STRING_LITERAL -> "throwsIndent" [673:33]
6664 | | | |--COMMA -> , [673:47]
6665 | | | `--EXPR -> EXPR [673:49]
6666 | | | `--STRING_LITERAL -> "4" [673:49]
6667 | | `--RPAREN -> ) [673:52]
6668 | |--SEMI -> ; [673:53]
6669 | |--VARIABLE_DEF -> VARIABLE_DEF [674:8]
6670 | | |--MODIFIERS -> MODIFIERS [674:8]
6671 | | | `--FINAL -> final [674:8]
6672 | | |--TYPE -> TYPE [674:20]
6673 | | | `--ARRAY_DECLARATOR -> [ [674:20]
6674 | | | |--IDENT -> String [674:14]
6675 | | | `--RBRACK -> ] [674:21]
6676 | | |--IDENT -> expected [674:23]
6677 | | `--ASSIGN -> = [674:32]
6678 | | `--ARRAY_INIT -> { [674:34]
6679 | | |--EXPR -> EXPR [675:22]
6680 | | | `--PLUS -> + [675:22]
6681 | | | |--STRING_LITERAL -> "24:11: " [675:12]
6682 | | | `--METHOD_CALL -> ( [675:39]
6683 | | | |--IDENT -> getCheckMessage [675:24]
6684 | | | |--ELIST -> ELIST [675:40]
6685 | | | | |--EXPR -> EXPR [675:40]
6686 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [675:40]
6687 | | | | |--COMMA -> , [675:61]
6688 | | | | |--EXPR -> EXPR [675:63]
6689 | | | | | `--STRING_LITERAL -> "label" [675:63]
6690 | | | | |--COMMA -> , [675:70]
6691 | | | | |--EXPR -> EXPR [675:72]
6692 | | | | | `--NUM_INT -> 10 [675:72]
6693 | | | | |--COMMA -> , [675:74]
6694 | | | | `--EXPR -> EXPR [675:76]
6695 | | | | `--STRING_LITERAL -> "8, 12" [675:76]
6696 | | | `--RPAREN -> ) [675:83]
6697 | | |--COMMA -> , [675:84]
6698 | | |--EXPR -> EXPR [676:21]
6699 | | | `--PLUS -> + [676:21]
6700 | | | |--STRING_LITERAL -> "33:3: " [676:12]
6701 | | | `--METHOD_CALL -> ( [676:38]
6702 | | | |--IDENT -> getCheckMessage [676:23]
6703 | | | |--ELIST -> ELIST [676:39]
6704 | | | | |--EXPR -> EXPR [676:39]
6705 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [676:39]
6706 | | | | |--COMMA -> , [676:60]
6707 | | | | |--EXPR -> EXPR [676:62]
6708 | | | | | `--STRING_LITERAL -> "label" [676:62]
6709 | | | | |--COMMA -> , [676:69]
6710 | | | | |--EXPR -> EXPR [676:71]
6711 | | | | | `--NUM_INT -> 2 [676:71]
6712 | | | | |--COMMA -> , [676:72]
6713 | | | | `--EXPR -> EXPR [676:74]
6714 | | | | `--STRING_LITERAL -> "4, 8" [676:74]
6715 | | | `--RPAREN -> ) [676:80]
6716 | | |--COMMA -> , [676:81]
6717 | | |--EXPR -> EXPR [677:22]
6718 | | | `--PLUS -> + [677:22]
6719 | | | |--STRING_LITERAL -> "36:19: " [677:12]
6720 | | | `--METHOD_CALL -> ( [677:39]
6721 | | | |--IDENT -> getCheckMessage [677:24]
6722 | | | |--ELIST -> ELIST [677:40]
6723 | | | | |--EXPR -> EXPR [677:40]
6724 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [677:40]
6725 | | | | |--COMMA -> , [677:61]
6726 | | | | |--EXPR -> EXPR [677:63]
6727 | | | | | `--STRING_LITERAL -> "label" [677:63]
6728 | | | | |--COMMA -> , [677:70]
6729 | | | | |--EXPR -> EXPR [677:72]
6730 | | | | | `--NUM_INT -> 18 [677:72]
6731 | | | | |--COMMA -> , [677:74]
6732 | | | | `--EXPR -> EXPR [677:76]
6733 | | | | `--STRING_LITERAL -> "8, 12" [677:76]
6734 | | | `--RPAREN -> ) [677:83]
6735 | | |--COMMA -> , [677:84]
6736 | | |--EXPR -> EXPR [678:22]
6737 | | | `--PLUS -> + [678:22]
6738 | | | |--STRING_LITERAL -> "37:19: " [678:12]
6739 | | | `--METHOD_CALL -> ( [678:39]
6740 | | | |--IDENT -> getCheckMessage [678:24]
6741 | | | |--ELIST -> ELIST [678:40]
6742 | | | | |--EXPR -> EXPR [678:40]
6743 | | | | | `--IDENT -> MSG_CHILD_ERROR [678:40]
6744 | | | | |--COMMA -> , [678:55]
6745 | | | | |--EXPR -> EXPR [678:57]
6746 | | | | | `--STRING_LITERAL -> "ctor def" [678:57]
6747 | | | | |--COMMA -> , [678:67]
6748 | | | | |--EXPR -> EXPR [678:69]
6749 | | | | | `--NUM_INT -> 18 [678:69]
6750 | | | | |--COMMA -> , [678:71]
6751 | | | | `--EXPR -> EXPR [678:73]
6752 | | | | `--NUM_INT -> 8 [678:73]
6753 | | | `--RPAREN -> ) [678:74]
6754 | | |--COMMA -> , [678:75]
6755 | | |--EXPR -> EXPR [679:21]
6756 | | | `--PLUS -> + [679:21]
6757 | | | |--STRING_LITERAL -> "39:7: " [679:12]
6758 | | | `--METHOD_CALL -> ( [679:38]
6759 | | | |--IDENT -> getCheckMessage [679:23]
6760 | | | |--ELIST -> ELIST [679:39]
6761 | | | | |--EXPR -> EXPR [679:39]
6762 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [679:39]
6763 | | | | |--COMMA -> , [679:60]
6764 | | | | |--EXPR -> EXPR [679:62]
6765 | | | | | `--STRING_LITERAL -> "label" [679:62]
6766 | | | | |--COMMA -> , [679:69]
6767 | | | | |--EXPR -> EXPR [679:71]
6768 | | | | | `--NUM_INT -> 6 [679:71]
6769 | | | | |--COMMA -> , [679:72]
6770 | | | | `--EXPR -> EXPR [679:74]
6771 | | | | `--STRING_LITERAL -> "8, 12" [679:74]
6772 | | | `--RPAREN -> ) [679:81]
6773 | | |--COMMA -> , [679:82]
6774 | | |--EXPR -> EXPR [680:21]
6775 | | | `--PLUS -> + [680:21]
6776 | | | |--STRING_LITERAL -> "41:7: " [680:12]
6777 | | | `--METHOD_CALL -> ( [680:38]
6778 | | | |--IDENT -> getCheckMessage [680:23]
6779 | | | |--ELIST -> ELIST [680:39]
6780 | | | | |--EXPR -> EXPR [680:39]
6781 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [680:39]
6782 | | | | |--COMMA -> , [680:60]
6783 | | | | |--EXPR -> EXPR [680:62]
6784 | | | | | `--STRING_LITERAL -> "label" [680:62]
6785 | | | | |--COMMA -> , [680:69]
6786 | | | | |--EXPR -> EXPR [680:71]
6787 | | | | | `--NUM_INT -> 6 [680:71]
6788 | | | | |--COMMA -> , [680:72]
6789 | | | | `--EXPR -> EXPR [680:74]
6790 | | | | `--STRING_LITERAL -> "8, 12" [680:74]
6791 | | | `--RPAREN -> ) [680:81]
6792 | | |--COMMA -> , [680:82]
6793 | | `--RCURLY -> } [681:8]
6794 | |--SEMI -> ; [681:9]
6795 | |--EXPR -> EXPR [682:19]
6796 | | `--METHOD_CALL -> ( [682:19]
6797 | | |--IDENT -> verifyWarns [682:8]
6798 | | |--ELIST -> ELIST [682:20]
6799 | | | |--EXPR -> EXPR [682:20]
6800 | | | | `--IDENT -> checkConfig [682:20]
6801 | | | |--COMMA -> , [682:31]
6802 | | | |--EXPR -> EXPR [682:40]
6803 | | | | `--METHOD_CALL -> ( [682:40]
6804 | | | | |--IDENT -> getPath [682:33]
6805 | | | | |--ELIST -> ELIST [682:41]
6806 | | | | | `--EXPR -> EXPR [682:41]
6807 | | | | | `--STRING_LITERAL -> "InputIndentationInvalidLabelIndent.java" [682:41]
6808 | | | | `--RPAREN -> ) [682:82]
6809 | | | |--COMMA -> , [682:83]
6810 | | | `--EXPR -> EXPR [682:85]
6811 | | | `--IDENT -> expected [682:85]
6812 | | `--RPAREN -> ) [682:93]
6813 | |--SEMI -> ; [682:94]
6814 | `--RCURLY -> } [683:4]
6815 |--METHOD_DEF -> METHOD_DEF [685:4]
6816 | |--MODIFIERS -> MODIFIERS [685:4]
6817 | | |--ANNOTATION -> ANNOTATION [685:4]
6818 | | | |--AT -> @ [685:4]
6819 | | | `--IDENT -> Test [685:5]
6820 | | `--LITERAL_PUBLIC -> public [686:4]
6821 | |--TYPE -> TYPE [686:11]
6822 | | `--LITERAL_VOID -> void [686:11]
6823 | |--IDENT -> testInvalidLabelWithWhileLoop [686:16]
6824 | |--LPAREN -> ( [686:45]
6825 | |--PARAMETERS -> PARAMETERS [686:46]
6826 | |--RPAREN -> ) [686:46]
6827 | |--LITERAL_THROWS -> throws [686:48]
6828 | | `--IDENT -> Exception [686:55]
6829 | `--SLIST -> { [686:65]
6830 | |--VARIABLE_DEF -> VARIABLE_DEF [687:8]
6831 | | |--MODIFIERS -> MODIFIERS [687:8]
6832 | | | `--FINAL -> final [687:8]
6833 | | |--TYPE -> TYPE [687:14]
6834 | | | `--IDENT -> DefaultConfiguration [687:14]
6835 | | |--IDENT -> checkConfig [687:35]
6836 | | `--ASSIGN -> = [687:47]
6837 | | `--EXPR -> EXPR [687:67]
6838 | | `--METHOD_CALL -> ( [687:67]
6839 | | |--IDENT -> createModuleConfig [687:49]
6840 | | |--ELIST -> ELIST [687:84]
6841 | | | `--EXPR -> EXPR [687:84]
6842 | | | `--DOT -> . [687:84]
6843 | | | |--IDENT -> IndentationCheck [687:68]
6844 | | | `--LITERAL_CLASS -> class [687:85]
6845 | | `--RPAREN -> ) [687:90]
6846 | |--SEMI -> ; [687:91]
6847 | |--EXPR -> EXPR [689:32]
6848 | | `--METHOD_CALL -> ( [689:32]
6849 | | |--DOT -> . [689:19]
6850 | | | |--IDENT -> checkConfig [689:8]
6851 | | | `--IDENT -> addAttribute [689:20]
6852 | | |--ELIST -> ELIST [689:33]
6853 | | | |--EXPR -> EXPR [689:33]
6854 | | | | `--STRING_LITERAL -> "arrayInitIndent" [689:33]
6855 | | | |--COMMA -> , [689:50]
6856 | | | `--EXPR -> EXPR [689:52]
6857 | | | `--STRING_LITERAL -> "4" [689:52]
6858 | | `--RPAREN -> ) [689:55]
6859 | |--SEMI -> ; [689:56]
6860 | |--EXPR -> EXPR [690:32]
6861 | | `--METHOD_CALL -> ( [690:32]
6862 | | |--DOT -> . [690:19]
6863 | | | |--IDENT -> checkConfig [690:8]
6864 | | | `--IDENT -> addAttribute [690:20]
6865 | | |--ELIST -> ELIST [690:33]
6866 | | | |--EXPR -> EXPR [690:33]
6867 | | | | `--STRING_LITERAL -> "basicOffset" [690:33]
6868 | | | |--COMMA -> , [690:46]
6869 | | | `--EXPR -> EXPR [690:48]
6870 | | | `--STRING_LITERAL -> "4" [690:48]
6871 | | `--RPAREN -> ) [690:51]
6872 | |--SEMI -> ; [690:52]
6873 | |--EXPR -> EXPR [691:32]
6874 | | `--METHOD_CALL -> ( [691:32]
6875 | | |--DOT -> . [691:19]
6876 | | | |--IDENT -> checkConfig [691:8]
6877 | | | `--IDENT -> addAttribute [691:20]
6878 | | |--ELIST -> ELIST [691:33]
6879 | | | |--EXPR -> EXPR [691:33]
6880 | | | | `--STRING_LITERAL -> "braceAdjustment" [691:33]
6881 | | | |--COMMA -> , [691:50]
6882 | | | `--EXPR -> EXPR [691:52]
6883 | | | `--STRING_LITERAL -> "0" [691:52]
6884 | | `--RPAREN -> ) [691:55]
6885 | |--SEMI -> ; [691:56]
6886 | |--EXPR -> EXPR [692:32]
6887 | | `--METHOD_CALL -> ( [692:32]
6888 | | |--DOT -> . [692:19]
6889 | | | |--IDENT -> checkConfig [692:8]
6890 | | | `--IDENT -> addAttribute [692:20]
6891 | | |--ELIST -> ELIST [692:33]
6892 | | | |--EXPR -> EXPR [692:33]
6893 | | | | `--STRING_LITERAL -> "caseIndent" [692:33]
6894 | | | |--COMMA -> , [692:45]
6895 | | | `--EXPR -> EXPR [692:47]
6896 | | | `--STRING_LITERAL -> "4" [692:47]
6897 | | `--RPAREN -> ) [692:50]
6898 | |--SEMI -> ; [692:51]
6899 | |--EXPR -> EXPR [693:32]
6900 | | `--METHOD_CALL -> ( [693:32]
6901 | | |--DOT -> . [693:19]
6902 | | | |--IDENT -> checkConfig [693:8]
6903 | | | `--IDENT -> addAttribute [693:20]
6904 | | |--ELIST -> ELIST [693:33]
6905 | | | |--EXPR -> EXPR [693:33]
6906 | | | | `--STRING_LITERAL -> "forceStrictCondition" [693:33]
6907 | | | |--COMMA -> , [693:55]
6908 | | | `--EXPR -> EXPR [693:57]
6909 | | | `--STRING_LITERAL -> "false" [693:57]
6910 | | `--RPAREN -> ) [693:64]
6911 | |--SEMI -> ; [693:65]
6912 | |--EXPR -> EXPR [694:32]
6913 | | `--METHOD_CALL -> ( [694:32]
6914 | | |--DOT -> . [694:19]
6915 | | | |--IDENT -> checkConfig [694:8]
6916 | | | `--IDENT -> addAttribute [694:20]
6917 | | |--ELIST -> ELIST [694:33]
6918 | | | |--EXPR -> EXPR [694:33]
6919 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [694:33]
6920 | | | |--COMMA -> , [694:58]
6921 | | | `--EXPR -> EXPR [694:60]
6922 | | | `--STRING_LITERAL -> "4" [694:60]
6923 | | `--RPAREN -> ) [694:63]
6924 | |--SEMI -> ; [694:64]
6925 | |--EXPR -> EXPR [695:32]
6926 | | `--METHOD_CALL -> ( [695:32]
6927 | | |--DOT -> . [695:19]
6928 | | | |--IDENT -> checkConfig [695:8]
6929 | | | `--IDENT -> addAttribute [695:20]
6930 | | |--ELIST -> ELIST [695:33]
6931 | | | |--EXPR -> EXPR [695:33]
6932 | | | | `--STRING_LITERAL -> "tabWidth" [695:33]
6933 | | | |--COMMA -> , [695:43]
6934 | | | `--EXPR -> EXPR [695:45]
6935 | | | `--STRING_LITERAL -> "4" [695:45]
6936 | | `--RPAREN -> ) [695:48]
6937 | |--SEMI -> ; [695:49]
6938 | |--EXPR -> EXPR [696:32]
6939 | | `--METHOD_CALL -> ( [696:32]
6940 | | |--DOT -> . [696:19]
6941 | | | |--IDENT -> checkConfig [696:8]
6942 | | | `--IDENT -> addAttribute [696:20]
6943 | | |--ELIST -> ELIST [696:33]
6944 | | | |--EXPR -> EXPR [696:33]
6945 | | | | `--STRING_LITERAL -> "throwsIndent" [696:33]
6946 | | | |--COMMA -> , [696:47]
6947 | | | `--EXPR -> EXPR [696:49]
6948 | | | `--STRING_LITERAL -> "4" [696:49]
6949 | | `--RPAREN -> ) [696:52]
6950 | |--SEMI -> ; [696:53]
6951 | |--VARIABLE_DEF -> VARIABLE_DEF [697:8]
6952 | | |--MODIFIERS -> MODIFIERS [697:8]
6953 | | | `--FINAL -> final [697:8]
6954 | | |--TYPE -> TYPE [697:20]
6955 | | | `--ARRAY_DECLARATOR -> [ [697:20]
6956 | | | |--IDENT -> String [697:14]
6957 | | | `--RBRACK -> ] [697:21]
6958 | | |--IDENT -> expected [697:23]
6959 | | `--ASSIGN -> = [697:32]
6960 | | `--ARRAY_INIT -> { [697:34]
6961 | | |--EXPR -> EXPR [698:22]
6962 | | | `--PLUS -> + [698:22]
6963 | | | |--STRING_LITERAL -> "18:10: " [698:12]
6964 | | | `--METHOD_CALL -> ( [698:39]
6965 | | | |--IDENT -> getCheckMessage [698:24]
6966 | | | |--ELIST -> ELIST [698:40]
6967 | | | | |--EXPR -> EXPR [698:40]
6968 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [698:40]
6969 | | | | |--COMMA -> , [698:61]
6970 | | | | |--EXPR -> EXPR [698:63]
6971 | | | | | `--STRING_LITERAL -> "label" [698:63]
6972 | | | | |--COMMA -> , [698:70]
6973 | | | | |--EXPR -> EXPR [698:72]
6974 | | | | | `--NUM_INT -> 9 [698:72]
6975 | | | | |--COMMA -> , [698:73]
6976 | | | | `--EXPR -> EXPR [698:75]
6977 | | | | `--STRING_LITERAL -> "4, 8" [698:75]
6978 | | | `--RPAREN -> ) [698:81]
6979 | | |--COMMA -> , [698:82]
6980 | | |--EXPR -> EXPR [699:22]
6981 | | | `--PLUS -> + [699:22]
6982 | | | |--STRING_LITERAL -> "19:10: " [699:12]
6983 | | | `--METHOD_CALL -> ( [699:39]
6984 | | | |--IDENT -> getCheckMessage [699:24]
6985 | | | |--ELIST -> ELIST [699:40]
6986 | | | | |--EXPR -> EXPR [699:40]
6987 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [699:40]
6988 | | | | |--COMMA -> , [699:61]
6989 | | | | |--EXPR -> EXPR [699:63]
6990 | | | | | `--STRING_LITERAL -> "label" [699:63]
6991 | | | | |--COMMA -> , [699:70]
6992 | | | | |--EXPR -> EXPR [699:72]
6993 | | | | | `--NUM_INT -> 9 [699:72]
6994 | | | | |--COMMA -> , [699:73]
6995 | | | | `--EXPR -> EXPR [699:75]
6996 | | | | `--STRING_LITERAL -> "8, 12" [699:75]
6997 | | | `--RPAREN -> ) [699:82]
6998 | | |--COMMA -> , [699:83]
6999 | | `--RCURLY -> } [700:8]
7000 | |--SEMI -> ; [700:9]
7001 | |--EXPR -> EXPR [701:19]
7002 | | `--METHOD_CALL -> ( [701:19]
7003 | | |--IDENT -> verifyWarns [701:8]
7004 | | |--ELIST -> ELIST [701:20]
7005 | | | |--EXPR -> EXPR [701:20]
7006 | | | | `--IDENT -> checkConfig [701:20]
7007 | | | |--COMMA -> , [701:31]
7008 | | | |--EXPR -> EXPR [701:40]
7009 | | | | `--METHOD_CALL -> ( [701:40]
7010 | | | | |--IDENT -> getPath [701:33]
7011 | | | | |--ELIST -> ELIST [701:41]
7012 | | | | | `--EXPR -> EXPR [701:41]
7013 | | | | | `--STRING_LITERAL -> "InputIndentationInvalidLabelWithWhileLoopIndent.java" [701:41]
7014 | | | | `--RPAREN -> ) [701:95]
7015 | | | |--COMMA -> , [701:96]
7016 | | | `--EXPR -> EXPR [702:12]
7017 | | | `--IDENT -> expected [702:12]
7018 | | `--RPAREN -> ) [702:20]
7019 | |--SEMI -> ; [702:21]
7020 | `--RCURLY -> } [703:4]
7021 |--METHOD_DEF -> METHOD_DEF [705:4]
7022 | |--MODIFIERS -> MODIFIERS [705:4]
7023 | | |--ANNOTATION -> ANNOTATION [705:4]
7024 | | | |--AT -> @ [705:4]
7025 | | | `--IDENT -> Test [705:5]
7026 | | `--LITERAL_PUBLIC -> public [706:4]
7027 | |--TYPE -> TYPE [706:11]
7028 | | `--LITERAL_VOID -> void [706:11]
7029 | |--IDENT -> testValidLabel [706:16]
7030 | |--LPAREN -> ( [706:30]
7031 | |--PARAMETERS -> PARAMETERS [706:31]
7032 | |--RPAREN -> ) [706:31]
7033 | |--LITERAL_THROWS -> throws [706:33]
7034 | | `--IDENT -> Exception [706:40]
7035 | `--SLIST -> { [706:50]
7036 | |--VARIABLE_DEF -> VARIABLE_DEF [707:8]
7037 | | |--MODIFIERS -> MODIFIERS [707:8]
7038 | | | `--FINAL -> final [707:8]
7039 | | |--TYPE -> TYPE [707:14]
7040 | | | `--IDENT -> DefaultConfiguration [707:14]
7041 | | |--IDENT -> checkConfig [707:35]
7042 | | `--ASSIGN -> = [707:47]
7043 | | `--EXPR -> EXPR [707:67]
7044 | | `--METHOD_CALL -> ( [707:67]
7045 | | |--IDENT -> createModuleConfig [707:49]
7046 | | |--ELIST -> ELIST [707:84]
7047 | | | `--EXPR -> EXPR [707:84]
7048 | | | `--DOT -> . [707:84]
7049 | | | |--IDENT -> IndentationCheck [707:68]
7050 | | | `--LITERAL_CLASS -> class [707:85]
7051 | | `--RPAREN -> ) [707:90]
7052 | |--SEMI -> ; [707:91]
7053 | |--EXPR -> EXPR [709:32]
7054 | | `--METHOD_CALL -> ( [709:32]
7055 | | |--DOT -> . [709:19]
7056 | | | |--IDENT -> checkConfig [709:8]
7057 | | | `--IDENT -> addAttribute [709:20]
7058 | | |--ELIST -> ELIST [709:33]
7059 | | | |--EXPR -> EXPR [709:33]
7060 | | | | `--STRING_LITERAL -> "arrayInitIndent" [709:33]
7061 | | | |--COMMA -> , [709:50]
7062 | | | `--EXPR -> EXPR [709:52]
7063 | | | `--STRING_LITERAL -> "4" [709:52]
7064 | | `--RPAREN -> ) [709:55]
7065 | |--SEMI -> ; [709:56]
7066 | |--EXPR -> EXPR [710:32]
7067 | | `--METHOD_CALL -> ( [710:32]
7068 | | |--DOT -> . [710:19]
7069 | | | |--IDENT -> checkConfig [710:8]
7070 | | | `--IDENT -> addAttribute [710:20]
7071 | | |--ELIST -> ELIST [710:33]
7072 | | | |--EXPR -> EXPR [710:33]
7073 | | | | `--STRING_LITERAL -> "basicOffset" [710:33]
7074 | | | |--COMMA -> , [710:46]
7075 | | | `--EXPR -> EXPR [710:48]
7076 | | | `--STRING_LITERAL -> "4" [710:48]
7077 | | `--RPAREN -> ) [710:51]
7078 | |--SEMI -> ; [710:52]
7079 | |--EXPR -> EXPR [711:32]
7080 | | `--METHOD_CALL -> ( [711:32]
7081 | | |--DOT -> . [711:19]
7082 | | | |--IDENT -> checkConfig [711:8]
7083 | | | `--IDENT -> addAttribute [711:20]
7084 | | |--ELIST -> ELIST [711:33]
7085 | | | |--EXPR -> EXPR [711:33]
7086 | | | | `--STRING_LITERAL -> "braceAdjustment" [711:33]
7087 | | | |--COMMA -> , [711:50]
7088 | | | `--EXPR -> EXPR [711:52]
7089 | | | `--STRING_LITERAL -> "0" [711:52]
7090 | | `--RPAREN -> ) [711:55]
7091 | |--SEMI -> ; [711:56]
7092 | |--EXPR -> EXPR [712:32]
7093 | | `--METHOD_CALL -> ( [712:32]
7094 | | |--DOT -> . [712:19]
7095 | | | |--IDENT -> checkConfig [712:8]
7096 | | | `--IDENT -> addAttribute [712:20]
7097 | | |--ELIST -> ELIST [712:33]
7098 | | | |--EXPR -> EXPR [712:33]
7099 | | | | `--STRING_LITERAL -> "caseIndent" [712:33]
7100 | | | |--COMMA -> , [712:45]
7101 | | | `--EXPR -> EXPR [712:47]
7102 | | | `--STRING_LITERAL -> "4" [712:47]
7103 | | `--RPAREN -> ) [712:50]
7104 | |--SEMI -> ; [712:51]
7105 | |--EXPR -> EXPR [713:32]
7106 | | `--METHOD_CALL -> ( [713:32]
7107 | | |--DOT -> . [713:19]
7108 | | | |--IDENT -> checkConfig [713:8]
7109 | | | `--IDENT -> addAttribute [713:20]
7110 | | |--ELIST -> ELIST [713:33]
7111 | | | |--EXPR -> EXPR [713:33]
7112 | | | | `--STRING_LITERAL -> "forceStrictCondition" [713:33]
7113 | | | |--COMMA -> , [713:55]
7114 | | | `--EXPR -> EXPR [713:57]
7115 | | | `--STRING_LITERAL -> "false" [713:57]
7116 | | `--RPAREN -> ) [713:64]
7117 | |--SEMI -> ; [713:65]
7118 | |--EXPR -> EXPR [714:32]
7119 | | `--METHOD_CALL -> ( [714:32]
7120 | | |--DOT -> . [714:19]
7121 | | | |--IDENT -> checkConfig [714:8]
7122 | | | `--IDENT -> addAttribute [714:20]
7123 | | |--ELIST -> ELIST [714:33]
7124 | | | |--EXPR -> EXPR [714:33]
7125 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [714:33]
7126 | | | |--COMMA -> , [714:58]
7127 | | | `--EXPR -> EXPR [714:60]
7128 | | | `--STRING_LITERAL -> "4" [714:60]
7129 | | `--RPAREN -> ) [714:63]
7130 | |--SEMI -> ; [714:64]
7131 | |--EXPR -> EXPR [715:32]
7132 | | `--METHOD_CALL -> ( [715:32]
7133 | | |--DOT -> . [715:19]
7134 | | | |--IDENT -> checkConfig [715:8]
7135 | | | `--IDENT -> addAttribute [715:20]
7136 | | |--ELIST -> ELIST [715:33]
7137 | | | |--EXPR -> EXPR [715:33]
7138 | | | | `--STRING_LITERAL -> "tabWidth" [715:33]
7139 | | | |--COMMA -> , [715:43]
7140 | | | `--EXPR -> EXPR [715:45]
7141 | | | `--STRING_LITERAL -> "4" [715:45]
7142 | | `--RPAREN -> ) [715:48]
7143 | |--SEMI -> ; [715:49]
7144 | |--EXPR -> EXPR [716:32]
7145 | | `--METHOD_CALL -> ( [716:32]
7146 | | |--DOT -> . [716:19]
7147 | | | |--IDENT -> checkConfig [716:8]
7148 | | | `--IDENT -> addAttribute [716:20]
7149 | | |--ELIST -> ELIST [716:33]
7150 | | | |--EXPR -> EXPR [716:33]
7151 | | | | `--STRING_LITERAL -> "throwsIndent" [716:33]
7152 | | | |--COMMA -> , [716:47]
7153 | | | `--EXPR -> EXPR [716:49]
7154 | | | `--STRING_LITERAL -> "4" [716:49]
7155 | | `--RPAREN -> ) [716:52]
7156 | |--SEMI -> ; [716:53]
7157 | |--VARIABLE_DEF -> VARIABLE_DEF [717:8]
7158 | | |--MODIFIERS -> MODIFIERS [717:8]
7159 | | | `--FINAL -> final [717:8]
7160 | | |--TYPE -> TYPE [717:20]
7161 | | | `--ARRAY_DECLARATOR -> [ [717:20]
7162 | | | |--IDENT -> String [717:14]
7163 | | | `--RBRACK -> ] [717:21]
7164 | | |--IDENT -> expected [717:23]
7165 | | `--ASSIGN -> = [717:32]
7166 | | `--EXPR -> EXPR [717:44]
7167 | | `--DOT -> . [717:44]
7168 | | |--IDENT -> CommonUtil [717:34]
7169 | | `--IDENT -> EMPTY_STRING_ARRAY [717:45]
7170 | |--SEMI -> ; [717:63]
7171 | |--EXPR -> EXPR [718:19]
7172 | | `--METHOD_CALL -> ( [718:19]
7173 | | |--IDENT -> verifyWarns [718:8]
7174 | | |--ELIST -> ELIST [718:20]
7175 | | | |--EXPR -> EXPR [718:20]
7176 | | | | `--IDENT -> checkConfig [718:20]
7177 | | | |--COMMA -> , [718:31]
7178 | | | |--EXPR -> EXPR [718:40]
7179 | | | | `--METHOD_CALL -> ( [718:40]
7180 | | | | |--IDENT -> getPath [718:33]
7181 | | | | |--ELIST -> ELIST [718:41]
7182 | | | | | `--EXPR -> EXPR [718:41]
7183 | | | | | `--STRING_LITERAL -> "InputIndentationValidLabelIndent.java" [718:41]
7184 | | | | `--RPAREN -> ) [718:80]
7185 | | | |--COMMA -> , [718:81]
7186 | | | `--EXPR -> EXPR [718:83]
7187 | | | `--IDENT -> expected [718:83]
7188 | | `--RPAREN -> ) [718:91]
7189 | |--SEMI -> ; [718:92]
7190 | `--RCURLY -> } [719:4]
7191 |--METHOD_DEF -> METHOD_DEF [721:4]
7192 | |--MODIFIERS -> MODIFIERS [721:4]
7193 | | |--ANNOTATION -> ANNOTATION [721:4]
7194 | | | |--AT -> @ [721:4]
7195 | | | `--IDENT -> Test [721:5]
7196 | | `--LITERAL_PUBLIC -> public [722:4]
7197 | |--TYPE -> TYPE [722:11]
7198 | | `--LITERAL_VOID -> void [722:11]
7199 | |--IDENT -> testValidIfWithChecker [722:16]
7200 | |--LPAREN -> ( [722:38]
7201 | |--PARAMETERS -> PARAMETERS [722:39]
7202 | |--RPAREN -> ) [722:39]
7203 | |--LITERAL_THROWS -> throws [722:41]
7204 | | `--IDENT -> Exception [722:48]
7205 | `--SLIST -> { [722:58]
7206 | |--VARIABLE_DEF -> VARIABLE_DEF [723:8]
7207 | | |--MODIFIERS -> MODIFIERS [723:8]
7208 | | | `--FINAL -> final [723:8]
7209 | | |--TYPE -> TYPE [723:14]
7210 | | | `--IDENT -> DefaultConfiguration [723:14]
7211 | | |--IDENT -> checkConfig [723:35]
7212 | | `--ASSIGN -> = [723:47]
7213 | | `--EXPR -> EXPR [723:67]
7214 | | `--METHOD_CALL -> ( [723:67]
7215 | | |--IDENT -> createModuleConfig [723:49]
7216 | | |--ELIST -> ELIST [723:84]
7217 | | | `--EXPR -> EXPR [723:84]
7218 | | | `--DOT -> . [723:84]
7219 | | | |--IDENT -> IndentationCheck [723:68]
7220 | | | `--LITERAL_CLASS -> class [723:85]
7221 | | `--RPAREN -> ) [723:90]
7222 | |--SEMI -> ; [723:91]
7223 | |--EXPR -> EXPR [725:32]
7224 | | `--METHOD_CALL -> ( [725:32]
7225 | | |--DOT -> . [725:19]
7226 | | | |--IDENT -> checkConfig [725:8]
7227 | | | `--IDENT -> addAttribute [725:20]
7228 | | |--ELIST -> ELIST [725:33]
7229 | | | |--EXPR -> EXPR [725:33]
7230 | | | | `--STRING_LITERAL -> "arrayInitIndent" [725:33]
7231 | | | |--COMMA -> , [725:50]
7232 | | | `--EXPR -> EXPR [725:52]
7233 | | | `--STRING_LITERAL -> "4" [725:52]
7234 | | `--RPAREN -> ) [725:55]
7235 | |--SEMI -> ; [725:56]
7236 | |--EXPR -> EXPR [726:32]
7237 | | `--METHOD_CALL -> ( [726:32]
7238 | | |--DOT -> . [726:19]
7239 | | | |--IDENT -> checkConfig [726:8]
7240 | | | `--IDENT -> addAttribute [726:20]
7241 | | |--ELIST -> ELIST [726:33]
7242 | | | |--EXPR -> EXPR [726:33]
7243 | | | | `--STRING_LITERAL -> "basicOffset" [726:33]
7244 | | | |--COMMA -> , [726:46]
7245 | | | `--EXPR -> EXPR [726:48]
7246 | | | `--STRING_LITERAL -> "4" [726:48]
7247 | | `--RPAREN -> ) [726:51]
7248 | |--SEMI -> ; [726:52]
7249 | |--EXPR -> EXPR [727:32]
7250 | | `--METHOD_CALL -> ( [727:32]
7251 | | |--DOT -> . [727:19]
7252 | | | |--IDENT -> checkConfig [727:8]
7253 | | | `--IDENT -> addAttribute [727:20]
7254 | | |--ELIST -> ELIST [727:33]
7255 | | | |--EXPR -> EXPR [727:33]
7256 | | | | `--STRING_LITERAL -> "braceAdjustment" [727:33]
7257 | | | |--COMMA -> , [727:50]
7258 | | | `--EXPR -> EXPR [727:52]
7259 | | | `--STRING_LITERAL -> "0" [727:52]
7260 | | `--RPAREN -> ) [727:55]
7261 | |--SEMI -> ; [727:56]
7262 | |--EXPR -> EXPR [728:32]
7263 | | `--METHOD_CALL -> ( [728:32]
7264 | | |--DOT -> . [728:19]
7265 | | | |--IDENT -> checkConfig [728:8]
7266 | | | `--IDENT -> addAttribute [728:20]
7267 | | |--ELIST -> ELIST [728:33]
7268 | | | |--EXPR -> EXPR [728:33]
7269 | | | | `--STRING_LITERAL -> "caseIndent" [728:33]
7270 | | | |--COMMA -> , [728:45]
7271 | | | `--EXPR -> EXPR [728:47]
7272 | | | `--STRING_LITERAL -> "4" [728:47]
7273 | | `--RPAREN -> ) [728:50]
7274 | |--SEMI -> ; [728:51]
7275 | |--EXPR -> EXPR [729:32]
7276 | | `--METHOD_CALL -> ( [729:32]
7277 | | |--DOT -> . [729:19]
7278 | | | |--IDENT -> checkConfig [729:8]
7279 | | | `--IDENT -> addAttribute [729:20]
7280 | | |--ELIST -> ELIST [729:33]
7281 | | | |--EXPR -> EXPR [729:33]
7282 | | | | `--STRING_LITERAL -> "forceStrictCondition" [729:33]
7283 | | | |--COMMA -> , [729:55]
7284 | | | `--EXPR -> EXPR [729:57]
7285 | | | `--STRING_LITERAL -> "false" [729:57]
7286 | | `--RPAREN -> ) [729:64]
7287 | |--SEMI -> ; [729:65]
7288 | |--EXPR -> EXPR [730:32]
7289 | | `--METHOD_CALL -> ( [730:32]
7290 | | |--DOT -> . [730:19]
7291 | | | |--IDENT -> checkConfig [730:8]
7292 | | | `--IDENT -> addAttribute [730:20]
7293 | | |--ELIST -> ELIST [730:33]
7294 | | | |--EXPR -> EXPR [730:33]
7295 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [730:33]
7296 | | | |--COMMA -> , [730:58]
7297 | | | `--EXPR -> EXPR [730:60]
7298 | | | `--STRING_LITERAL -> "4" [730:60]
7299 | | `--RPAREN -> ) [730:63]
7300 | |--SEMI -> ; [730:64]
7301 | |--EXPR -> EXPR [731:32]
7302 | | `--METHOD_CALL -> ( [731:32]
7303 | | |--DOT -> . [731:19]
7304 | | | |--IDENT -> checkConfig [731:8]
7305 | | | `--IDENT -> addAttribute [731:20]
7306 | | |--ELIST -> ELIST [731:33]
7307 | | | |--EXPR -> EXPR [731:33]
7308 | | | | `--STRING_LITERAL -> "tabWidth" [731:33]
7309 | | | |--COMMA -> , [731:43]
7310 | | | `--EXPR -> EXPR [731:45]
7311 | | | `--STRING_LITERAL -> "4" [731:45]
7312 | | `--RPAREN -> ) [731:48]
7313 | |--SEMI -> ; [731:49]
7314 | |--EXPR -> EXPR [732:32]
7315 | | `--METHOD_CALL -> ( [732:32]
7316 | | |--DOT -> . [732:19]
7317 | | | |--IDENT -> checkConfig [732:8]
7318 | | | `--IDENT -> addAttribute [732:20]
7319 | | |--ELIST -> ELIST [732:33]
7320 | | | |--EXPR -> EXPR [732:33]
7321 | | | | `--STRING_LITERAL -> "throwsIndent" [732:33]
7322 | | | |--COMMA -> , [732:47]
7323 | | | `--EXPR -> EXPR [732:49]
7324 | | | `--STRING_LITERAL -> "4" [732:49]
7325 | | `--RPAREN -> ) [732:52]
7326 | |--SEMI -> ; [732:53]
7327 | |--VARIABLE_DEF -> VARIABLE_DEF [733:8]
7328 | | |--MODIFIERS -> MODIFIERS [733:8]
7329 | | | `--FINAL -> final [733:8]
7330 | | |--TYPE -> TYPE [733:14]
7331 | | | `--IDENT -> String [733:14]
7332 | | |--IDENT -> fileName [733:21]
7333 | | `--ASSIGN -> = [733:30]
7334 | | `--EXPR -> EXPR [733:39]
7335 | | `--METHOD_CALL -> ( [733:39]
7336 | | |--IDENT -> getPath [733:32]
7337 | | |--ELIST -> ELIST [733:40]
7338 | | | `--EXPR -> EXPR [733:40]
7339 | | | `--STRING_LITERAL -> "InputIndentationValidIfIndent.java" [733:40]
7340 | | `--RPAREN -> ) [733:76]
7341 | |--SEMI -> ; [733:77]
7342 | |--VARIABLE_DEF -> VARIABLE_DEF [734:8]
7343 | | |--MODIFIERS -> MODIFIERS [734:8]
7344 | | | `--FINAL -> final [734:8]
7345 | | |--TYPE -> TYPE [734:20]
7346 | | | `--ARRAY_DECLARATOR -> [ [734:20]
7347 | | | |--IDENT -> String [734:14]
7348 | | | `--RBRACK -> ] [734:21]
7349 | | |--IDENT -> expected [734:23]
7350 | | `--ASSIGN -> = [734:32]
7351 | | `--ARRAY_INIT -> { [734:34]
7352 | | |--EXPR -> EXPR [735:22]
7353 | | | `--PLUS -> + [735:22]
7354 | | | |--STRING_LITERAL -> "231:9: " [735:12]
7355 | | | `--METHOD_CALL -> ( [735:39]
7356 | | | |--IDENT -> getCheckMessage [735:24]
7357 | | | |--ELIST -> ELIST [735:40]
7358 | | | | |--EXPR -> EXPR [735:40]
7359 | | | | | `--IDENT -> MSG_ERROR [735:40]
7360 | | | | |--COMMA -> , [735:49]
7361 | | | | |--EXPR -> EXPR [735:51]
7362 | | | | | `--STRING_LITERAL -> "(" [735:51]
7363 | | | | |--COMMA -> , [735:54]
7364 | | | | |--EXPR -> EXPR [735:56]
7365 | | | | | `--NUM_INT -> 8 [735:56]
7366 | | | | |--COMMA -> , [735:57]
7367 | | | | `--EXPR -> EXPR [735:59]
7368 | | | | `--NUM_INT -> 12 [735:59]
7369 | | | `--RPAREN -> ) [735:61]
7370 | | |--COMMA -> , [735:62]
7371 | | `--RCURLY -> } [736:8]
7372 | |--SEMI -> ; [736:9]
7373 | |--EXPR -> EXPR [737:19]
7374 | | `--METHOD_CALL -> ( [737:19]
7375 | | |--IDENT -> verifyWarns [737:8]
7376 | | |--ELIST -> ELIST [737:20]
7377 | | | |--EXPR -> EXPR [737:20]
7378 | | | | `--IDENT -> checkConfig [737:20]
7379 | | | |--COMMA -> , [737:31]
7380 | | | |--EXPR -> EXPR [737:33]
7381 | | | | `--IDENT -> fileName [737:33]
7382 | | | |--COMMA -> , [737:41]
7383 | | | `--EXPR -> EXPR [737:43]
7384 | | | `--IDENT -> expected [737:43]
7385 | | `--RPAREN -> ) [737:51]
7386 | |--SEMI -> ; [737:52]
7387 | `--RCURLY -> } [738:4]
7388 |--METHOD_DEF -> METHOD_DEF [740:4]
7389 | |--MODIFIERS -> MODIFIERS [740:4]
7390 | | |--ANNOTATION -> ANNOTATION [740:4]
7391 | | | |--AT -> @ [740:4]
7392 | | | `--IDENT -> Test [740:5]
7393 | | `--LITERAL_PUBLIC -> public [741:4]
7394 | |--TYPE -> TYPE [741:11]
7395 | | `--LITERAL_VOID -> void [741:11]
7396 | |--IDENT -> testValidDotWithChecker [741:16]
7397 | |--LPAREN -> ( [741:39]
7398 | |--PARAMETERS -> PARAMETERS [741:40]
7399 | |--RPAREN -> ) [741:40]
7400 | |--LITERAL_THROWS -> throws [742:12]
7401 | | `--IDENT -> Exception [742:19]
7402 | `--SLIST -> { [742:29]
7403 | |--VARIABLE_DEF -> VARIABLE_DEF [743:8]
7404 | | |--MODIFIERS -> MODIFIERS [743:8]
7405 | | | `--FINAL -> final [743:8]
7406 | | |--TYPE -> TYPE [743:14]
7407 | | | `--IDENT -> DefaultConfiguration [743:14]
7408 | | |--IDENT -> checkConfig [743:35]
7409 | | `--ASSIGN -> = [743:47]
7410 | | `--EXPR -> EXPR [743:67]
7411 | | `--METHOD_CALL -> ( [743:67]
7412 | | |--IDENT -> createModuleConfig [743:49]
7413 | | |--ELIST -> ELIST [743:84]
7414 | | | `--EXPR -> EXPR [743:84]
7415 | | | `--DOT -> . [743:84]
7416 | | | |--IDENT -> IndentationCheck [743:68]
7417 | | | `--LITERAL_CLASS -> class [743:85]
7418 | | `--RPAREN -> ) [743:90]
7419 | |--SEMI -> ; [743:91]
7420 | |--EXPR -> EXPR [745:32]
7421 | | `--METHOD_CALL -> ( [745:32]
7422 | | |--DOT -> . [745:19]
7423 | | | |--IDENT -> checkConfig [745:8]
7424 | | | `--IDENT -> addAttribute [745:20]
7425 | | |--ELIST -> ELIST [745:33]
7426 | | | |--EXPR -> EXPR [745:33]
7427 | | | | `--STRING_LITERAL -> "arrayInitIndent" [745:33]
7428 | | | |--COMMA -> , [745:50]
7429 | | | `--EXPR -> EXPR [745:52]
7430 | | | `--STRING_LITERAL -> "4" [745:52]
7431 | | `--RPAREN -> ) [745:55]
7432 | |--SEMI -> ; [745:56]
7433 | |--EXPR -> EXPR [746:32]
7434 | | `--METHOD_CALL -> ( [746:32]
7435 | | |--DOT -> . [746:19]
7436 | | | |--IDENT -> checkConfig [746:8]
7437 | | | `--IDENT -> addAttribute [746:20]
7438 | | |--ELIST -> ELIST [746:33]
7439 | | | |--EXPR -> EXPR [746:33]
7440 | | | | `--STRING_LITERAL -> "basicOffset" [746:33]
7441 | | | |--COMMA -> , [746:46]
7442 | | | `--EXPR -> EXPR [746:48]
7443 | | | `--STRING_LITERAL -> "4" [746:48]
7444 | | `--RPAREN -> ) [746:51]
7445 | |--SEMI -> ; [746:52]
7446 | |--EXPR -> EXPR [747:32]
7447 | | `--METHOD_CALL -> ( [747:32]
7448 | | |--DOT -> . [747:19]
7449 | | | |--IDENT -> checkConfig [747:8]
7450 | | | `--IDENT -> addAttribute [747:20]
7451 | | |--ELIST -> ELIST [747:33]
7452 | | | |--EXPR -> EXPR [747:33]
7453 | | | | `--STRING_LITERAL -> "braceAdjustment" [747:33]
7454 | | | |--COMMA -> , [747:50]
7455 | | | `--EXPR -> EXPR [747:52]
7456 | | | `--STRING_LITERAL -> "0" [747:52]
7457 | | `--RPAREN -> ) [747:55]
7458 | |--SEMI -> ; [747:56]
7459 | |--EXPR -> EXPR [748:32]
7460 | | `--METHOD_CALL -> ( [748:32]
7461 | | |--DOT -> . [748:19]
7462 | | | |--IDENT -> checkConfig [748:8]
7463 | | | `--IDENT -> addAttribute [748:20]
7464 | | |--ELIST -> ELIST [748:33]
7465 | | | |--EXPR -> EXPR [748:33]
7466 | | | | `--STRING_LITERAL -> "caseIndent" [748:33]
7467 | | | |--COMMA -> , [748:45]
7468 | | | `--EXPR -> EXPR [748:47]
7469 | | | `--STRING_LITERAL -> "4" [748:47]
7470 | | `--RPAREN -> ) [748:50]
7471 | |--SEMI -> ; [748:51]
7472 | |--EXPR -> EXPR [749:32]
7473 | | `--METHOD_CALL -> ( [749:32]
7474 | | |--DOT -> . [749:19]
7475 | | | |--IDENT -> checkConfig [749:8]
7476 | | | `--IDENT -> addAttribute [749:20]
7477 | | |--ELIST -> ELIST [749:33]
7478 | | | |--EXPR -> EXPR [749:33]
7479 | | | | `--STRING_LITERAL -> "forceStrictCondition" [749:33]
7480 | | | |--COMMA -> , [749:55]
7481 | | | `--EXPR -> EXPR [749:57]
7482 | | | `--STRING_LITERAL -> "false" [749:57]
7483 | | `--RPAREN -> ) [749:64]
7484 | |--SEMI -> ; [749:65]
7485 | |--EXPR -> EXPR [750:32]
7486 | | `--METHOD_CALL -> ( [750:32]
7487 | | |--DOT -> . [750:19]
7488 | | | |--IDENT -> checkConfig [750:8]
7489 | | | `--IDENT -> addAttribute [750:20]
7490 | | |--ELIST -> ELIST [750:33]
7491 | | | |--EXPR -> EXPR [750:33]
7492 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [750:33]
7493 | | | |--COMMA -> , [750:58]
7494 | | | `--EXPR -> EXPR [750:60]
7495 | | | `--STRING_LITERAL -> "4" [750:60]
7496 | | `--RPAREN -> ) [750:63]
7497 | |--SEMI -> ; [750:64]
7498 | |--EXPR -> EXPR [751:32]
7499 | | `--METHOD_CALL -> ( [751:32]
7500 | | |--DOT -> . [751:19]
7501 | | | |--IDENT -> checkConfig [751:8]
7502 | | | `--IDENT -> addAttribute [751:20]
7503 | | |--ELIST -> ELIST [751:33]
7504 | | | |--EXPR -> EXPR [751:33]
7505 | | | | `--STRING_LITERAL -> "tabWidth" [751:33]
7506 | | | |--COMMA -> , [751:43]
7507 | | | `--EXPR -> EXPR [751:45]
7508 | | | `--STRING_LITERAL -> "4" [751:45]
7509 | | `--RPAREN -> ) [751:48]
7510 | |--SEMI -> ; [751:49]
7511 | |--EXPR -> EXPR [752:32]
7512 | | `--METHOD_CALL -> ( [752:32]
7513 | | |--DOT -> . [752:19]
7514 | | | |--IDENT -> checkConfig [752:8]
7515 | | | `--IDENT -> addAttribute [752:20]
7516 | | |--ELIST -> ELIST [752:33]
7517 | | | |--EXPR -> EXPR [752:33]
7518 | | | | `--STRING_LITERAL -> "throwsIndent" [752:33]
7519 | | | |--COMMA -> , [752:47]
7520 | | | `--EXPR -> EXPR [752:49]
7521 | | | `--STRING_LITERAL -> "4" [752:49]
7522 | | `--RPAREN -> ) [752:52]
7523 | |--SEMI -> ; [752:53]
7524 | |--VARIABLE_DEF -> VARIABLE_DEF [753:8]
7525 | | |--MODIFIERS -> MODIFIERS [753:8]
7526 | | | `--FINAL -> final [753:8]
7527 | | |--TYPE -> TYPE [753:14]
7528 | | | `--IDENT -> String [753:14]
7529 | | |--IDENT -> fileName [753:21]
7530 | | `--ASSIGN -> = [753:30]
7531 | | `--EXPR -> EXPR [753:39]
7532 | | `--METHOD_CALL -> ( [753:39]
7533 | | |--IDENT -> getPath [753:32]
7534 | | |--ELIST -> ELIST [753:40]
7535 | | | `--EXPR -> EXPR [753:40]
7536 | | | `--STRING_LITERAL -> "InputIndentationValidDotIndent.java" [753:40]
7537 | | `--RPAREN -> ) [753:77]
7538 | |--SEMI -> ; [753:78]
7539 | |--VARIABLE_DEF -> VARIABLE_DEF [754:8]
7540 | | |--MODIFIERS -> MODIFIERS [754:8]
7541 | | | `--FINAL -> final [754:8]
7542 | | |--TYPE -> TYPE [754:20]
7543 | | | `--ARRAY_DECLARATOR -> [ [754:20]
7544 | | | |--IDENT -> String [754:14]
7545 | | | `--RBRACK -> ] [754:21]
7546 | | |--IDENT -> expected [754:23]
7547 | | `--ASSIGN -> = [754:32]
7548 | | `--EXPR -> EXPR [754:44]
7549 | | `--DOT -> . [754:44]
7550 | | |--IDENT -> CommonUtil [754:34]
7551 | | `--IDENT -> EMPTY_STRING_ARRAY [754:45]
7552 | |--SEMI -> ; [754:63]
7553 | |--EXPR -> EXPR [755:19]
7554 | | `--METHOD_CALL -> ( [755:19]
7555 | | |--IDENT -> verifyWarns [755:8]
7556 | | |--ELIST -> ELIST [755:20]
7557 | | | |--EXPR -> EXPR [755:20]
7558 | | | | `--IDENT -> checkConfig [755:20]
7559 | | | |--COMMA -> , [755:31]
7560 | | | |--EXPR -> EXPR [755:33]
7561 | | | | `--IDENT -> fileName [755:33]
7562 | | | |--COMMA -> , [755:41]
7563 | | | `--EXPR -> EXPR [755:43]
7564 | | | `--IDENT -> expected [755:43]
7565 | | `--RPAREN -> ) [755:51]
7566 | |--SEMI -> ; [755:52]
7567 | `--RCURLY -> } [756:4]
7568 |--METHOD_DEF -> METHOD_DEF [758:4]
7569 | |--MODIFIERS -> MODIFIERS [758:4]
7570 | | |--ANNOTATION -> ANNOTATION [758:4]
7571 | | | |--AT -> @ [758:4]
7572 | | | `--IDENT -> Test [758:5]
7573 | | `--LITERAL_PUBLIC -> public [759:4]
7574 | |--TYPE -> TYPE [759:11]
7575 | | `--LITERAL_VOID -> void [759:11]
7576 | |--IDENT -> testValidMethodWithChecker [759:16]
7577 | |--LPAREN -> ( [759:42]
7578 | |--PARAMETERS -> PARAMETERS [759:43]
7579 | |--RPAREN -> ) [759:43]
7580 | |--LITERAL_THROWS -> throws [760:12]
7581 | | `--IDENT -> Exception [760:19]
7582 | `--SLIST -> { [760:29]
7583 | |--VARIABLE_DEF -> VARIABLE_DEF [761:8]
7584 | | |--MODIFIERS -> MODIFIERS [761:8]
7585 | | | `--FINAL -> final [761:8]
7586 | | |--TYPE -> TYPE [761:14]
7587 | | | `--IDENT -> DefaultConfiguration [761:14]
7588 | | |--IDENT -> checkConfig [761:35]
7589 | | `--ASSIGN -> = [761:47]
7590 | | `--EXPR -> EXPR [761:67]
7591 | | `--METHOD_CALL -> ( [761:67]
7592 | | |--IDENT -> createModuleConfig [761:49]
7593 | | |--ELIST -> ELIST [761:84]
7594 | | | `--EXPR -> EXPR [761:84]
7595 | | | `--DOT -> . [761:84]
7596 | | | |--IDENT -> IndentationCheck [761:68]
7597 | | | `--LITERAL_CLASS -> class [761:85]
7598 | | `--RPAREN -> ) [761:90]
7599 | |--SEMI -> ; [761:91]
7600 | |--EXPR -> EXPR [763:32]
7601 | | `--METHOD_CALL -> ( [763:32]
7602 | | |--DOT -> . [763:19]
7603 | | | |--IDENT -> checkConfig [763:8]
7604 | | | `--IDENT -> addAttribute [763:20]
7605 | | |--ELIST -> ELIST [763:33]
7606 | | | |--EXPR -> EXPR [763:33]
7607 | | | | `--STRING_LITERAL -> "arrayInitIndent" [763:33]
7608 | | | |--COMMA -> , [763:50]
7609 | | | `--EXPR -> EXPR [763:52]
7610 | | | `--STRING_LITERAL -> "4" [763:52]
7611 | | `--RPAREN -> ) [763:55]
7612 | |--SEMI -> ; [763:56]
7613 | |--EXPR -> EXPR [764:32]
7614 | | `--METHOD_CALL -> ( [764:32]
7615 | | |--DOT -> . [764:19]
7616 | | | |--IDENT -> checkConfig [764:8]
7617 | | | `--IDENT -> addAttribute [764:20]
7618 | | |--ELIST -> ELIST [764:33]
7619 | | | |--EXPR -> EXPR [764:33]
7620 | | | | `--STRING_LITERAL -> "basicOffset" [764:33]
7621 | | | |--COMMA -> , [764:46]
7622 | | | `--EXPR -> EXPR [764:48]
7623 | | | `--STRING_LITERAL -> "4" [764:48]
7624 | | `--RPAREN -> ) [764:51]
7625 | |--SEMI -> ; [764:52]
7626 | |--EXPR -> EXPR [765:32]
7627 | | `--METHOD_CALL -> ( [765:32]
7628 | | |--DOT -> . [765:19]
7629 | | | |--IDENT -> checkConfig [765:8]
7630 | | | `--IDENT -> addAttribute [765:20]
7631 | | |--ELIST -> ELIST [765:33]
7632 | | | |--EXPR -> EXPR [765:33]
7633 | | | | `--STRING_LITERAL -> "braceAdjustment" [765:33]
7634 | | | |--COMMA -> , [765:50]
7635 | | | `--EXPR -> EXPR [765:52]
7636 | | | `--STRING_LITERAL -> "0" [765:52]
7637 | | `--RPAREN -> ) [765:55]
7638 | |--SEMI -> ; [765:56]
7639 | |--EXPR -> EXPR [766:32]
7640 | | `--METHOD_CALL -> ( [766:32]
7641 | | |--DOT -> . [766:19]
7642 | | | |--IDENT -> checkConfig [766:8]
7643 | | | `--IDENT -> addAttribute [766:20]
7644 | | |--ELIST -> ELIST [766:33]
7645 | | | |--EXPR -> EXPR [766:33]
7646 | | | | `--STRING_LITERAL -> "caseIndent" [766:33]
7647 | | | |--COMMA -> , [766:45]
7648 | | | `--EXPR -> EXPR [766:47]
7649 | | | `--STRING_LITERAL -> "4" [766:47]
7650 | | `--RPAREN -> ) [766:50]
7651 | |--SEMI -> ; [766:51]
7652 | |--EXPR -> EXPR [767:32]
7653 | | `--METHOD_CALL -> ( [767:32]
7654 | | |--DOT -> . [767:19]
7655 | | | |--IDENT -> checkConfig [767:8]
7656 | | | `--IDENT -> addAttribute [767:20]
7657 | | |--ELIST -> ELIST [767:33]
7658 | | | |--EXPR -> EXPR [767:33]
7659 | | | | `--STRING_LITERAL -> "forceStrictCondition" [767:33]
7660 | | | |--COMMA -> , [767:55]
7661 | | | `--EXPR -> EXPR [767:57]
7662 | | | `--STRING_LITERAL -> "false" [767:57]
7663 | | `--RPAREN -> ) [767:64]
7664 | |--SEMI -> ; [767:65]
7665 | |--EXPR -> EXPR [768:32]
7666 | | `--METHOD_CALL -> ( [768:32]
7667 | | |--DOT -> . [768:19]
7668 | | | |--IDENT -> checkConfig [768:8]
7669 | | | `--IDENT -> addAttribute [768:20]
7670 | | |--ELIST -> ELIST [768:33]
7671 | | | |--EXPR -> EXPR [768:33]
7672 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [768:33]
7673 | | | |--COMMA -> , [768:58]
7674 | | | `--EXPR -> EXPR [768:60]
7675 | | | `--STRING_LITERAL -> "4" [768:60]
7676 | | `--RPAREN -> ) [768:63]
7677 | |--SEMI -> ; [768:64]
7678 | |--EXPR -> EXPR [769:32]
7679 | | `--METHOD_CALL -> ( [769:32]
7680 | | |--DOT -> . [769:19]
7681 | | | |--IDENT -> checkConfig [769:8]
7682 | | | `--IDENT -> addAttribute [769:20]
7683 | | |--ELIST -> ELIST [769:33]
7684 | | | |--EXPR -> EXPR [769:33]
7685 | | | | `--STRING_LITERAL -> "tabWidth" [769:33]
7686 | | | |--COMMA -> , [769:43]
7687 | | | `--EXPR -> EXPR [769:45]
7688 | | | `--STRING_LITERAL -> "4" [769:45]
7689 | | `--RPAREN -> ) [769:48]
7690 | |--SEMI -> ; [769:49]
7691 | |--EXPR -> EXPR [770:32]
7692 | | `--METHOD_CALL -> ( [770:32]
7693 | | |--DOT -> . [770:19]
7694 | | | |--IDENT -> checkConfig [770:8]
7695 | | | `--IDENT -> addAttribute [770:20]
7696 | | |--ELIST -> ELIST [770:33]
7697 | | | |--EXPR -> EXPR [770:33]
7698 | | | | `--STRING_LITERAL -> "throwsIndent" [770:33]
7699 | | | |--COMMA -> , [770:47]
7700 | | | `--EXPR -> EXPR [770:49]
7701 | | | `--STRING_LITERAL -> "4" [770:49]
7702 | | `--RPAREN -> ) [770:52]
7703 | |--SEMI -> ; [770:53]
7704 | |--VARIABLE_DEF -> VARIABLE_DEF [771:8]
7705 | | |--MODIFIERS -> MODIFIERS [771:8]
7706 | | | `--FINAL -> final [771:8]
7707 | | |--TYPE -> TYPE [771:14]
7708 | | | `--IDENT -> String [771:14]
7709 | | |--IDENT -> fileName [771:21]
7710 | | `--ASSIGN -> = [771:30]
7711 | | `--EXPR -> EXPR [771:39]
7712 | | `--METHOD_CALL -> ( [771:39]
7713 | | |--IDENT -> getPath [771:32]
7714 | | |--ELIST -> ELIST [771:40]
7715 | | | `--EXPR -> EXPR [771:40]
7716 | | | `--STRING_LITERAL -> "InputIndentationValidMethodIndent.java" [771:40]
7717 | | `--RPAREN -> ) [771:80]
7718 | |--SEMI -> ; [771:81]
7719 | |--VARIABLE_DEF -> VARIABLE_DEF [772:8]
7720 | | |--MODIFIERS -> MODIFIERS [772:8]
7721 | | | `--FINAL -> final [772:8]
7722 | | |--TYPE -> TYPE [772:20]
7723 | | | `--ARRAY_DECLARATOR -> [ [772:20]
7724 | | | |--IDENT -> String [772:14]
7725 | | | `--RBRACK -> ] [772:21]
7726 | | |--IDENT -> expected [772:23]
7727 | | `--ASSIGN -> = [772:32]
7728 | | `--ARRAY_INIT -> { [772:34]
7729 | | |--EXPR -> EXPR [773:22]
7730 | | | `--PLUS -> + [773:22]
7731 | | | |--STRING_LITERAL -> "129:5: " [773:12]
7732 | | | `--METHOD_CALL -> ( [773:39]
7733 | | | |--IDENT -> getCheckMessage [773:24]
7734 | | | |--ELIST -> ELIST [773:40]
7735 | | | | |--EXPR -> EXPR [773:40]
7736 | | | | | `--IDENT -> MSG_ERROR [773:40]
7737 | | | | |--COMMA -> , [773:49]
7738 | | | | |--EXPR -> EXPR [773:51]
7739 | | | | | `--STRING_LITERAL -> "void" [773:51]
7740 | | | | |--COMMA -> , [773:57]
7741 | | | | |--EXPR -> EXPR [773:59]
7742 | | | | | `--NUM_INT -> 4 [773:59]
7743 | | | | |--COMMA -> , [773:60]
7744 | | | | `--EXPR -> EXPR [773:62]
7745 | | | | `--NUM_INT -> 8 [773:62]
7746 | | | `--RPAREN -> ) [773:63]
7747 | | |--COMMA -> , [773:64]
7748 | | |--EXPR -> EXPR [774:22]
7749 | | | `--PLUS -> + [774:22]
7750 | | | |--STRING_LITERAL -> "130:5: " [774:12]
7751 | | | `--METHOD_CALL -> ( [774:39]
7752 | | | |--IDENT -> getCheckMessage [774:24]
7753 | | | |--ELIST -> ELIST [774:40]
7754 | | | | |--EXPR -> EXPR [774:40]
7755 | | | | | `--IDENT -> MSG_ERROR [774:40]
7756 | | | | |--COMMA -> , [774:49]
7757 | | | | |--EXPR -> EXPR [774:51]
7758 | | | | | `--STRING_LITERAL -> "method5" [774:51]
7759 | | | | |--COMMA -> , [774:60]
7760 | | | | |--EXPR -> EXPR [774:62]
7761 | | | | | `--NUM_INT -> 4 [774:62]
7762 | | | | |--COMMA -> , [774:63]
7763 | | | | `--EXPR -> EXPR [774:65]
7764 | | | | `--NUM_INT -> 8 [774:65]
7765 | | | `--RPAREN -> ) [774:66]
7766 | | |--COMMA -> , [774:67]
7767 | | `--RCURLY -> } [775:8]
7768 | |--SEMI -> ; [775:9]
7769 | |--EXPR -> EXPR [776:19]
7770 | | `--METHOD_CALL -> ( [776:19]
7771 | | |--IDENT -> verifyWarns [776:8]
7772 | | |--ELIST -> ELIST [776:20]
7773 | | | |--EXPR -> EXPR [776:20]
7774 | | | | `--IDENT -> checkConfig [776:20]
7775 | | | |--COMMA -> , [776:31]
7776 | | | |--EXPR -> EXPR [776:33]
7777 | | | | `--IDENT -> fileName [776:33]
7778 | | | |--COMMA -> , [776:41]
7779 | | | `--EXPR -> EXPR [776:43]
7780 | | | `--IDENT -> expected [776:43]
7781 | | `--RPAREN -> ) [776:51]
7782 | |--SEMI -> ; [776:52]
7783 | `--RCURLY -> } [777:4]
7784 |--METHOD_DEF -> METHOD_DEF [779:4]
7785 | |--MODIFIERS -> MODIFIERS [779:4]
7786 | | |--ANNOTATION -> ANNOTATION [779:4]
7787 | | | |--AT -> @ [779:4]
7788 | | | `--IDENT -> Test [779:5]
7789 | | `--LITERAL_PUBLIC -> public [780:4]
7790 | |--TYPE -> TYPE [780:11]
7791 | | `--LITERAL_VOID -> void [780:11]
7792 | |--IDENT -> testInvalidMethodWithChecker [780:16]
7793 | |--LPAREN -> ( [780:44]
7794 | |--PARAMETERS -> PARAMETERS [780:45]
7795 | |--RPAREN -> ) [780:45]
7796 | |--LITERAL_THROWS -> throws [781:12]
7797 | | `--IDENT -> Exception [781:19]
7798 | `--SLIST -> { [781:29]
7799 | |--VARIABLE_DEF -> VARIABLE_DEF [782:8]
7800 | | |--MODIFIERS -> MODIFIERS [782:8]
7801 | | | `--FINAL -> final [782:8]
7802 | | |--TYPE -> TYPE [782:14]
7803 | | | `--IDENT -> DefaultConfiguration [782:14]
7804 | | |--IDENT -> checkConfig [782:35]
7805 | | `--ASSIGN -> = [782:47]
7806 | | `--EXPR -> EXPR [782:67]
7807 | | `--METHOD_CALL -> ( [782:67]
7808 | | |--IDENT -> createModuleConfig [782:49]
7809 | | |--ELIST -> ELIST [782:84]
7810 | | | `--EXPR -> EXPR [782:84]
7811 | | | `--DOT -> . [782:84]
7812 | | | |--IDENT -> IndentationCheck [782:68]
7813 | | | `--LITERAL_CLASS -> class [782:85]
7814 | | `--RPAREN -> ) [782:90]
7815 | |--SEMI -> ; [782:91]
7816 | |--EXPR -> EXPR [784:32]
7817 | | `--METHOD_CALL -> ( [784:32]
7818 | | |--DOT -> . [784:19]
7819 | | | |--IDENT -> checkConfig [784:8]
7820 | | | `--IDENT -> addAttribute [784:20]
7821 | | |--ELIST -> ELIST [784:33]
7822 | | | |--EXPR -> EXPR [784:33]
7823 | | | | `--STRING_LITERAL -> "arrayInitIndent" [784:33]
7824 | | | |--COMMA -> , [784:50]
7825 | | | `--EXPR -> EXPR [784:52]
7826 | | | `--STRING_LITERAL -> "4" [784:52]
7827 | | `--RPAREN -> ) [784:55]
7828 | |--SEMI -> ; [784:56]
7829 | |--EXPR -> EXPR [785:32]
7830 | | `--METHOD_CALL -> ( [785:32]
7831 | | |--DOT -> . [785:19]
7832 | | | |--IDENT -> checkConfig [785:8]
7833 | | | `--IDENT -> addAttribute [785:20]
7834 | | |--ELIST -> ELIST [785:33]
7835 | | | |--EXPR -> EXPR [785:33]
7836 | | | | `--STRING_LITERAL -> "basicOffset" [785:33]
7837 | | | |--COMMA -> , [785:46]
7838 | | | `--EXPR -> EXPR [785:48]
7839 | | | `--STRING_LITERAL -> "4" [785:48]
7840 | | `--RPAREN -> ) [785:51]
7841 | |--SEMI -> ; [785:52]
7842 | |--EXPR -> EXPR [786:32]
7843 | | `--METHOD_CALL -> ( [786:32]
7844 | | |--DOT -> . [786:19]
7845 | | | |--IDENT -> checkConfig [786:8]
7846 | | | `--IDENT -> addAttribute [786:20]
7847 | | |--ELIST -> ELIST [786:33]
7848 | | | |--EXPR -> EXPR [786:33]
7849 | | | | `--STRING_LITERAL -> "braceAdjustment" [786:33]
7850 | | | |--COMMA -> , [786:50]
7851 | | | `--EXPR -> EXPR [786:52]
7852 | | | `--STRING_LITERAL -> "0" [786:52]
7853 | | `--RPAREN -> ) [786:55]
7854 | |--SEMI -> ; [786:56]
7855 | |--EXPR -> EXPR [787:32]
7856 | | `--METHOD_CALL -> ( [787:32]
7857 | | |--DOT -> . [787:19]
7858 | | | |--IDENT -> checkConfig [787:8]
7859 | | | `--IDENT -> addAttribute [787:20]
7860 | | |--ELIST -> ELIST [787:33]
7861 | | | |--EXPR -> EXPR [787:33]
7862 | | | | `--STRING_LITERAL -> "caseIndent" [787:33]
7863 | | | |--COMMA -> , [787:45]
7864 | | | `--EXPR -> EXPR [787:47]
7865 | | | `--STRING_LITERAL -> "4" [787:47]
7866 | | `--RPAREN -> ) [787:50]
7867 | |--SEMI -> ; [787:51]
7868 | |--EXPR -> EXPR [788:32]
7869 | | `--METHOD_CALL -> ( [788:32]
7870 | | |--DOT -> . [788:19]
7871 | | | |--IDENT -> checkConfig [788:8]
7872 | | | `--IDENT -> addAttribute [788:20]
7873 | | |--ELIST -> ELIST [788:33]
7874 | | | |--EXPR -> EXPR [788:33]
7875 | | | | `--STRING_LITERAL -> "forceStrictCondition" [788:33]
7876 | | | |--COMMA -> , [788:55]
7877 | | | `--EXPR -> EXPR [788:57]
7878 | | | `--STRING_LITERAL -> "false" [788:57]
7879 | | `--RPAREN -> ) [788:64]
7880 | |--SEMI -> ; [788:65]
7881 | |--EXPR -> EXPR [789:32]
7882 | | `--METHOD_CALL -> ( [789:32]
7883 | | |--DOT -> . [789:19]
7884 | | | |--IDENT -> checkConfig [789:8]
7885 | | | `--IDENT -> addAttribute [789:20]
7886 | | |--ELIST -> ELIST [789:33]
7887 | | | |--EXPR -> EXPR [789:33]
7888 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [789:33]
7889 | | | |--COMMA -> , [789:58]
7890 | | | `--EXPR -> EXPR [789:60]
7891 | | | `--STRING_LITERAL -> "4" [789:60]
7892 | | `--RPAREN -> ) [789:63]
7893 | |--SEMI -> ; [789:64]
7894 | |--EXPR -> EXPR [790:32]
7895 | | `--METHOD_CALL -> ( [790:32]
7896 | | |--DOT -> . [790:19]
7897 | | | |--IDENT -> checkConfig [790:8]
7898 | | | `--IDENT -> addAttribute [790:20]
7899 | | |--ELIST -> ELIST [790:33]
7900 | | | |--EXPR -> EXPR [790:33]
7901 | | | | `--STRING_LITERAL -> "tabWidth" [790:33]
7902 | | | |--COMMA -> , [790:43]
7903 | | | `--EXPR -> EXPR [790:45]
7904 | | | `--STRING_LITERAL -> "4" [790:45]
7905 | | `--RPAREN -> ) [790:48]
7906 | |--SEMI -> ; [790:49]
7907 | |--EXPR -> EXPR [791:32]
7908 | | `--METHOD_CALL -> ( [791:32]
7909 | | |--DOT -> . [791:19]
7910 | | | |--IDENT -> checkConfig [791:8]
7911 | | | `--IDENT -> addAttribute [791:20]
7912 | | |--ELIST -> ELIST [791:33]
7913 | | | |--EXPR -> EXPR [791:33]
7914 | | | | `--STRING_LITERAL -> "throwsIndent" [791:33]
7915 | | | |--COMMA -> , [791:47]
7916 | | | `--EXPR -> EXPR [791:49]
7917 | | | `--STRING_LITERAL -> "4" [791:49]
7918 | | `--RPAREN -> ) [791:52]
7919 | |--SEMI -> ; [791:53]
7920 | |--VARIABLE_DEF -> VARIABLE_DEF [792:8]
7921 | | |--MODIFIERS -> MODIFIERS [792:8]
7922 | | | `--FINAL -> final [792:8]
7923 | | |--TYPE -> TYPE [792:14]
7924 | | | `--IDENT -> String [792:14]
7925 | | |--IDENT -> fileName [792:21]
7926 | | `--ASSIGN -> = [792:30]
7927 | | `--EXPR -> EXPR [792:39]
7928 | | `--METHOD_CALL -> ( [792:39]
7929 | | |--IDENT -> getPath [792:32]
7930 | | |--ELIST -> ELIST [792:40]
7931 | | | `--EXPR -> EXPR [792:40]
7932 | | | `--STRING_LITERAL -> "InputIndentationInvalidMethodIndent.java" [792:40]
7933 | | `--RPAREN -> ) [792:82]
7934 | |--SEMI -> ; [792:83]
7935 | |--VARIABLE_DEF -> VARIABLE_DEF [793:8]
7936 | | |--MODIFIERS -> MODIFIERS [793:8]
7937 | | | `--FINAL -> final [793:8]
7938 | | |--TYPE -> TYPE [793:20]
7939 | | | `--ARRAY_DECLARATOR -> [ [793:20]
7940 | | | |--IDENT -> String [793:14]
7941 | | | `--RBRACK -> ] [793:21]
7942 | | |--IDENT -> expected [793:23]
7943 | | `--ASSIGN -> = [793:32]
7944 | | `--ARRAY_INIT -> { [793:34]
7945 | | |--EXPR -> EXPR [794:21]
7946 | | | `--PLUS -> + [794:21]
7947 | | | |--STRING_LITERAL -> "23:7: " [794:12]
7948 | | | `--METHOD_CALL -> ( [794:38]
7949 | | | |--IDENT -> getCheckMessage [794:23]
7950 | | | |--ELIST -> ELIST [794:39]
7951 | | | | |--EXPR -> EXPR [794:39]
7952 | | | | | `--IDENT -> MSG_ERROR [794:39]
7953 | | | | |--COMMA -> , [794:48]
7954 | | | | |--EXPR -> EXPR [794:50]
7955 | | | | | `--STRING_LITERAL -> "ctor def rcurly" [794:50]
7956 | | | | |--COMMA -> , [794:67]
7957 | | | | |--EXPR -> EXPR [794:69]
7958 | | | | | `--NUM_INT -> 6 [794:69]
7959 | | | | |--COMMA -> , [794:70]
7960 | | | | `--EXPR -> EXPR [794:72]
7961 | | | | `--NUM_INT -> 4 [794:72]
7962 | | | `--RPAREN -> ) [794:73]
7963 | | |--COMMA -> , [794:74]
7964 | | |--EXPR -> EXPR [795:21]
7965 | | | `--PLUS -> + [795:21]
7966 | | | |--STRING_LITERAL -> "26:7: " [795:12]
7967 | | | `--METHOD_CALL -> ( [795:38]
7968 | | | |--IDENT -> getCheckMessage [795:23]
7969 | | | |--ELIST -> ELIST [795:39]
7970 | | | | |--EXPR -> EXPR [795:39]
7971 | | | | | `--IDENT -> MSG_ERROR [795:39]
7972 | | | | |--COMMA -> , [795:48]
7973 | | | | |--EXPR -> EXPR [795:50]
7974 | | | | | `--STRING_LITERAL -> "ctor def modifier" [795:50]
7975 | | | | |--COMMA -> , [795:69]
7976 | | | | |--EXPR -> EXPR [795:71]
7977 | | | | | `--NUM_INT -> 6 [795:71]
7978 | | | | |--COMMA -> , [795:72]
7979 | | | | `--EXPR -> EXPR [795:74]
7980 | | | | `--NUM_INT -> 4 [795:74]
7981 | | | `--RPAREN -> ) [795:75]
7982 | | |--COMMA -> , [795:76]
7983 | | |--EXPR -> EXPR [796:21]
7984 | | | `--PLUS -> + [796:21]
7985 | | | |--STRING_LITERAL -> "27:3: " [796:12]
7986 | | | `--METHOD_CALL -> ( [796:38]
7987 | | | |--IDENT -> getCheckMessage [796:23]
7988 | | | |--ELIST -> ELIST [796:39]
7989 | | | | |--EXPR -> EXPR [796:39]
7990 | | | | | `--IDENT -> MSG_ERROR [796:39]
7991 | | | | |--COMMA -> , [796:48]
7992 | | | | |--EXPR -> EXPR [796:50]
7993 | | | | | `--STRING_LITERAL -> "ctor def lcurly" [796:50]
7994 | | | | |--COMMA -> , [796:67]
7995 | | | | |--EXPR -> EXPR [796:69]
7996 | | | | | `--NUM_INT -> 2 [796:69]
7997 | | | | |--COMMA -> , [796:70]
7998 | | | | `--EXPR -> EXPR [796:72]
7999 | | | | `--NUM_INT -> 4 [796:72]
8000 | | | `--RPAREN -> ) [796:73]
8001 | | |--COMMA -> , [796:74]
8002 | | |--EXPR -> EXPR [797:21]
8003 | | | `--PLUS -> + [797:21]
8004 | | | |--STRING_LITERAL -> "28:7: " [797:12]
8005 | | | `--METHOD_CALL -> ( [797:38]
8006 | | | |--IDENT -> getCheckMessage [797:23]
8007 | | | |--ELIST -> ELIST [797:39]
8008 | | | | |--EXPR -> EXPR [797:39]
8009 | | | | | `--IDENT -> MSG_ERROR [797:39]
8010 | | | | |--COMMA -> , [797:48]
8011 | | | | |--EXPR -> EXPR [797:50]
8012 | | | | | `--STRING_LITERAL -> "ctor def rcurly" [797:50]
8013 | | | | |--COMMA -> , [797:67]
8014 | | | | |--EXPR -> EXPR [797:69]
8015 | | | | | `--NUM_INT -> 6 [797:69]
8016 | | | | |--COMMA -> , [797:70]
8017 | | | | `--EXPR -> EXPR [797:72]
8018 | | | | `--NUM_INT -> 4 [797:72]
8019 | | | `--RPAREN -> ) [797:73]
8020 | | |--COMMA -> , [797:74]
8021 | | |--EXPR -> EXPR [798:21]
8022 | | | `--PLUS -> + [798:21]
8023 | | | |--STRING_LITERAL -> "31:3: " [798:12]
8024 | | | `--METHOD_CALL -> ( [798:38]
8025 | | | |--IDENT -> getCheckMessage [798:23]
8026 | | | |--ELIST -> ELIST [798:39]
8027 | | | | |--EXPR -> EXPR [798:39]
8028 | | | | | `--IDENT -> MSG_ERROR [798:39]
8029 | | | | |--COMMA -> , [798:48]
8030 | | | | |--EXPR -> EXPR [798:50]
8031 | | | | | `--STRING_LITERAL -> "method def modifier" [798:50]
8032 | | | | |--COMMA -> , [798:71]
8033 | | | | |--EXPR -> EXPR [798:73]
8034 | | | | | `--NUM_INT -> 2 [798:73]
8035 | | | | |--COMMA -> , [798:74]
8036 | | | | `--EXPR -> EXPR [798:76]
8037 | | | | `--NUM_INT -> 4 [798:76]
8038 | | | `--RPAREN -> ) [798:77]
8039 | | |--COMMA -> , [798:78]
8040 | | |--EXPR -> EXPR [799:21]
8041 | | | `--PLUS -> + [799:21]
8042 | | | |--STRING_LITERAL -> "32:7: " [799:12]
8043 | | | `--METHOD_CALL -> ( [799:38]
8044 | | | |--IDENT -> getCheckMessage [799:23]
8045 | | | |--ELIST -> ELIST [799:39]
8046 | | | | |--EXPR -> EXPR [799:39]
8047 | | | | | `--IDENT -> MSG_ERROR [799:39]
8048 | | | | |--COMMA -> , [799:48]
8049 | | | | |--EXPR -> EXPR [799:50]
8050 | | | | | `--STRING_LITERAL -> "method def rcurly" [799:50]
8051 | | | | |--COMMA -> , [799:69]
8052 | | | | |--EXPR -> EXPR [799:71]
8053 | | | | | `--NUM_INT -> 6 [799:71]
8054 | | | | |--COMMA -> , [799:72]
8055 | | | | `--EXPR -> EXPR [799:74]
8056 | | | | `--NUM_INT -> 4 [799:74]
8057 | | | `--RPAREN -> ) [799:75]
8058 | | |--COMMA -> , [799:76]
8059 | | |--EXPR -> EXPR [800:21]
8060 | | | `--PLUS -> + [800:21]
8061 | | | |--STRING_LITERAL -> "69:6: " [800:12]
8062 | | | `--METHOD_CALL -> ( [800:38]
8063 | | | |--IDENT -> getCheckMessage [800:23]
8064 | | | |--ELIST -> ELIST [800:39]
8065 | | | | |--EXPR -> EXPR [800:39]
8066 | | | | | `--IDENT -> MSG_ERROR [800:39]
8067 | | | | |--COMMA -> , [800:48]
8068 | | | | |--EXPR -> EXPR [800:50]
8069 | | | | | `--STRING_LITERAL -> "method def modifier" [800:50]
8070 | | | | |--COMMA -> , [800:71]
8071 | | | | |--EXPR -> EXPR [800:73]
8072 | | | | | `--NUM_INT -> 5 [800:73]
8073 | | | | |--COMMA -> , [800:74]
8074 | | | | `--EXPR -> EXPR [800:76]
8075 | | | | `--NUM_INT -> 4 [800:76]
8076 | | | `--RPAREN -> ) [800:77]
8077 | | |--COMMA -> , [800:78]
8078 | | |--EXPR -> EXPR [801:21]
8079 | | | `--PLUS -> + [801:21]
8080 | | | |--STRING_LITERAL -> "70:6: " [801:12]
8081 | | | `--METHOD_CALL -> ( [801:38]
8082 | | | |--IDENT -> getCheckMessage [801:23]
8083 | | | |--ELIST -> ELIST [801:39]
8084 | | | | |--EXPR -> EXPR [801:39]
8085 | | | | | `--IDENT -> MSG_ERROR [801:39]
8086 | | | | |--COMMA -> , [801:48]
8087 | | | | |--EXPR -> EXPR [801:50]
8088 | | | | | `--STRING_LITERAL -> "final" [801:50]
8089 | | | | |--COMMA -> , [801:57]
8090 | | | | |--EXPR -> EXPR [801:59]
8091 | | | | | `--NUM_INT -> 5 [801:59]
8092 | | | | |--COMMA -> , [801:60]
8093 | | | | `--EXPR -> EXPR [801:62]
8094 | | | | `--NUM_INT -> 9 [801:62]
8095 | | | `--RPAREN -> ) [801:63]
8096 | | |--COMMA -> , [801:64]
8097 | | |--EXPR -> EXPR [802:21]
8098 | | | `--PLUS -> + [802:21]
8099 | | | |--STRING_LITERAL -> "71:6: " [802:12]
8100 | | | `--METHOD_CALL -> ( [802:38]
8101 | | | |--IDENT -> getCheckMessage [802:23]
8102 | | | |--ELIST -> ELIST [802:39]
8103 | | | | |--EXPR -> EXPR [802:39]
8104 | | | | | `--IDENT -> MSG_ERROR [802:39]
8105 | | | | |--COMMA -> , [802:48]
8106 | | | | |--EXPR -> EXPR [802:50]
8107 | | | | | `--STRING_LITERAL -> "void" [802:50]
8108 | | | | |--COMMA -> , [802:56]
8109 | | | | |--EXPR -> EXPR [802:58]
8110 | | | | | `--NUM_INT -> 5 [802:58]
8111 | | | | |--COMMA -> , [802:59]
8112 | | | | `--EXPR -> EXPR [802:61]
8113 | | | | `--NUM_INT -> 9 [802:61]
8114 | | | `--RPAREN -> ) [802:62]
8115 | | |--COMMA -> , [802:63]
8116 | | |--EXPR -> EXPR [803:21]
8117 | | | `--PLUS -> + [803:21]
8118 | | | |--STRING_LITERAL -> "72:5: " [803:12]
8119 | | | `--METHOD_CALL -> ( [803:38]
8120 | | | |--IDENT -> getCheckMessage [803:23]
8121 | | | |--ELIST -> ELIST [803:39]
8122 | | | | |--EXPR -> EXPR [803:39]
8123 | | | | | `--IDENT -> MSG_ERROR [803:39]
8124 | | | | |--COMMA -> , [803:48]
8125 | | | | |--EXPR -> EXPR [803:50]
8126 | | | | | `--STRING_LITERAL -> "method5" [803:50]
8127 | | | | |--COMMA -> , [803:59]
8128 | | | | |--EXPR -> EXPR [803:61]
8129 | | | | | `--NUM_INT -> 4 [803:61]
8130 | | | | |--COMMA -> , [803:62]
8131 | | | | `--EXPR -> EXPR [803:64]
8132 | | | | `--NUM_INT -> 9 [803:64]
8133 | | | `--RPAREN -> ) [803:65]
8134 | | |--COMMA -> , [803:66]
8135 | | |--EXPR -> EXPR [804:21]
8136 | | | `--PLUS -> + [804:21]
8137 | | | |--STRING_LITERAL -> "80:4: " [804:12]
8138 | | | `--METHOD_CALL -> ( [804:38]
8139 | | | |--IDENT -> getCheckMessage [804:23]
8140 | | | |--ELIST -> ELIST [804:39]
8141 | | | | |--EXPR -> EXPR [804:39]
8142 | | | | | `--IDENT -> MSG_ERROR [804:39]
8143 | | | | |--COMMA -> , [804:48]
8144 | | | | |--EXPR -> EXPR [804:50]
8145 | | | | | `--STRING_LITERAL -> "method def modifier" [804:50]
8146 | | | | |--COMMA -> , [804:71]
8147 | | | | |--EXPR -> EXPR [804:73]
8148 | | | | | `--NUM_INT -> 3 [804:73]
8149 | | | | |--COMMA -> , [804:74]
8150 | | | | `--EXPR -> EXPR [804:76]
8151 | | | | `--NUM_INT -> 4 [804:76]
8152 | | | `--RPAREN -> ) [804:77]
8153 | | |--COMMA -> , [804:78]
8154 | | |--EXPR -> EXPR [805:21]
8155 | | | `--PLUS -> + [805:21]
8156 | | | |--STRING_LITERAL -> "81:4: " [805:12]
8157 | | | `--METHOD_CALL -> ( [805:38]
8158 | | | |--IDENT -> getCheckMessage [805:23]
8159 | | | |--ELIST -> ELIST [805:39]
8160 | | | | |--EXPR -> EXPR [805:39]
8161 | | | | | `--IDENT -> MSG_ERROR [805:39]
8162 | | | | |--COMMA -> , [805:48]
8163 | | | | |--EXPR -> EXPR [805:50]
8164 | | | | | `--STRING_LITERAL -> "final" [805:50]
8165 | | | | |--COMMA -> , [805:57]
8166 | | | | |--EXPR -> EXPR [805:59]
8167 | | | | | `--NUM_INT -> 3 [805:59]
8168 | | | | |--COMMA -> , [805:60]
8169 | | | | `--EXPR -> EXPR [805:62]
8170 | | | | `--NUM_INT -> 7 [805:62]
8171 | | | `--RPAREN -> ) [805:63]
8172 | | |--COMMA -> , [805:64]
8173 | | |--EXPR -> EXPR [806:21]
8174 | | | `--PLUS -> + [806:21]
8175 | | | |--STRING_LITERAL -> "82:4: " [806:12]
8176 | | | `--METHOD_CALL -> ( [806:38]
8177 | | | |--IDENT -> getCheckMessage [806:23]
8178 | | | |--ELIST -> ELIST [806:39]
8179 | | | | |--EXPR -> EXPR [806:39]
8180 | | | | | `--IDENT -> MSG_ERROR [806:39]
8181 | | | | |--COMMA -> , [806:48]
8182 | | | | |--EXPR -> EXPR [806:50]
8183 | | | | | `--STRING_LITERAL -> "void" [806:50]
8184 | | | | |--COMMA -> , [806:56]
8185 | | | | |--EXPR -> EXPR [806:58]
8186 | | | | | `--NUM_INT -> 3 [806:58]
8187 | | | | |--COMMA -> , [806:59]
8188 | | | | `--EXPR -> EXPR [806:61]
8189 | | | | `--NUM_INT -> 7 [806:61]
8190 | | | `--RPAREN -> ) [806:62]
8191 | | |--COMMA -> , [806:63]
8192 | | |--EXPR -> EXPR [807:21]
8193 | | | `--PLUS -> + [807:21]
8194 | | | |--STRING_LITERAL -> "83:6: " [807:12]
8195 | | | `--METHOD_CALL -> ( [807:38]
8196 | | | |--IDENT -> getCheckMessage [807:23]
8197 | | | |--ELIST -> ELIST [807:39]
8198 | | | | |--EXPR -> EXPR [807:39]
8199 | | | | | `--IDENT -> MSG_ERROR [807:39]
8200 | | | | |--COMMA -> , [807:48]
8201 | | | | |--EXPR -> EXPR [807:50]
8202 | | | | | `--STRING_LITERAL -> "method6" [807:50]
8203 | | | | |--COMMA -> , [807:59]
8204 | | | | |--EXPR -> EXPR [807:61]
8205 | | | | | `--NUM_INT -> 5 [807:61]
8206 | | | | |--COMMA -> , [807:62]
8207 | | | | `--EXPR -> EXPR [807:64]
8208 | | | | `--NUM_INT -> 7 [807:64]
8209 | | | `--RPAREN -> ) [807:65]
8210 | | |--COMMA -> , [807:66]
8211 | | |--EXPR -> EXPR [808:21]
8212 | | | `--PLUS -> + [808:21]
8213 | | | |--STRING_LITERAL -> "93:5: " [808:12]
8214 | | | `--METHOD_CALL -> ( [808:38]
8215 | | | |--IDENT -> getCheckMessage [808:23]
8216 | | | |--ELIST -> ELIST [808:39]
8217 | | | | |--EXPR -> EXPR [808:39]
8218 | | | | | `--IDENT -> MSG_CHILD_ERROR [808:39]
8219 | | | | |--COMMA -> , [808:54]
8220 | | | | |--EXPR -> EXPR [808:56]
8221 | | | | | `--STRING_LITERAL -> "ctor def" [808:56]
8222 | | | | |--COMMA -> , [808:66]
8223 | | | | |--EXPR -> EXPR [808:68]
8224 | | | | | `--NUM_INT -> 4 [808:68]
8225 | | | | |--COMMA -> , [808:69]
8226 | | | | `--EXPR -> EXPR [808:71]
8227 | | | | `--NUM_INT -> 8 [808:71]
8228 | | | `--RPAREN -> ) [808:72]
8229 | | |--COMMA -> , [808:73]
8230 | | |--EXPR -> EXPR [809:21]
8231 | | | `--PLUS -> + [809:21]
8232 | | | |--STRING_LITERAL -> "98:7: " [809:12]
8233 | | | `--METHOD_CALL -> ( [809:38]
8234 | | | |--IDENT -> getCheckMessage [809:23]
8235 | | | |--ELIST -> ELIST [809:39]
8236 | | | | |--EXPR -> EXPR [809:39]
8237 | | | | | `--IDENT -> MSG_CHILD_ERROR [809:39]
8238 | | | | |--COMMA -> , [809:54]
8239 | | | | |--EXPR -> EXPR [809:56]
8240 | | | | | `--STRING_LITERAL -> "method def" [809:56]
8241 | | | | |--COMMA -> , [809:68]
8242 | | | | |--EXPR -> EXPR [809:70]
8243 | | | | | `--NUM_INT -> 6 [809:70]
8244 | | | | |--COMMA -> , [809:71]
8245 | | | | `--EXPR -> EXPR [809:73]
8246 | | | | `--NUM_INT -> 8 [809:73]
8247 | | | `--RPAREN -> ) [809:74]
8248 | | |--COMMA -> , [809:75]
8249 | | |--EXPR -> EXPR [810:21]
8250 | | | `--PLUS -> + [810:21]
8251 | | | |--STRING_LITERAL -> "99:7: " [810:12]
8252 | | | `--METHOD_CALL -> ( [810:38]
8253 | | | |--IDENT -> getCheckMessage [810:23]
8254 | | | |--ELIST -> ELIST [810:39]
8255 | | | | |--EXPR -> EXPR [810:39]
8256 | | | | | `--IDENT -> MSG_ERROR [810:39]
8257 | | | | |--COMMA -> , [810:48]
8258 | | | | |--EXPR -> EXPR [810:50]
8259 | | | | | `--STRING_LITERAL -> "if" [810:50]
8260 | | | | |--COMMA -> , [810:54]
8261 | | | | |--EXPR -> EXPR [810:56]
8262 | | | | | `--NUM_INT -> 6 [810:56]
8263 | | | | |--COMMA -> , [810:57]
8264 | | | | `--EXPR -> EXPR [810:59]
8265 | | | | `--NUM_INT -> 8 [810:59]
8266 | | | `--RPAREN -> ) [810:60]
8267 | | |--COMMA -> , [810:61]
8268 | | |--EXPR -> EXPR [811:23]
8269 | | | `--PLUS -> + [811:23]
8270 | | | |--STRING_LITERAL -> "100:11: " [811:12]
8271 | | | `--METHOD_CALL -> ( [811:40]
8272 | | | |--IDENT -> getCheckMessage [811:25]
8273 | | | |--ELIST -> ELIST [811:41]
8274 | | | | |--EXPR -> EXPR [811:41]
8275 | | | | | `--IDENT -> MSG_CHILD_ERROR [811:41]
8276 | | | | |--COMMA -> , [811:56]
8277 | | | | |--EXPR -> EXPR [811:58]
8278 | | | | | `--STRING_LITERAL -> "if" [811:58]
8279 | | | | |--COMMA -> , [811:62]
8280 | | | | |--EXPR -> EXPR [811:64]
8281 | | | | | `--NUM_INT -> 10 [811:64]
8282 | | | | |--COMMA -> , [811:66]
8283 | | | | `--EXPR -> EXPR [811:68]
8284 | | | | `--NUM_INT -> 12 [811:68]
8285 | | | `--RPAREN -> ) [811:70]
8286 | | |--COMMA -> , [811:71]
8287 | | |--EXPR -> EXPR [812:22]
8288 | | | `--PLUS -> + [812:22]
8289 | | | |--STRING_LITERAL -> "101:7: " [812:12]
8290 | | | `--METHOD_CALL -> ( [812:39]
8291 | | | |--IDENT -> getCheckMessage [812:24]
8292 | | | |--ELIST -> ELIST [812:40]
8293 | | | | |--EXPR -> EXPR [812:40]
8294 | | | | | `--IDENT -> MSG_ERROR [812:40]
8295 | | | | |--COMMA -> , [812:49]
8296 | | | | |--EXPR -> EXPR [812:51]
8297 | | | | | `--STRING_LITERAL -> "if rcurly" [812:51]
8298 | | | | |--COMMA -> , [812:62]
8299 | | | | |--EXPR -> EXPR [812:64]
8300 | | | | | `--NUM_INT -> 6 [812:64]
8301 | | | | |--COMMA -> , [812:65]
8302 | | | | `--EXPR -> EXPR [812:67]
8303 | | | | `--NUM_INT -> 8 [812:67]
8304 | | | `--RPAREN -> ) [812:68]
8305 | | |--COMMA -> , [812:69]
8306 | | |--EXPR -> EXPR [813:23]
8307 | | | `--PLUS -> + [813:23]
8308 | | | |--STRING_LITERAL -> "104:11: " [813:12]
8309 | | | `--METHOD_CALL -> ( [813:40]
8310 | | | |--IDENT -> getCheckMessage [813:25]
8311 | | | |--ELIST -> ELIST [813:41]
8312 | | | | |--EXPR -> EXPR [813:41]
8313 | | | | | `--IDENT -> MSG_ERROR [813:41]
8314 | | | | |--COMMA -> , [813:50]
8315 | | | | |--EXPR -> EXPR [813:52]
8316 | | | | | `--STRING_LITERAL -> "Arrays" [813:52]
8317 | | | | |--COMMA -> , [813:60]
8318 | | | | |--EXPR -> EXPR [813:62]
8319 | | | | | `--NUM_INT -> 10 [813:62]
8320 | | | | |--COMMA -> , [813:64]
8321 | | | | `--EXPR -> EXPR [813:66]
8322 | | | | `--NUM_INT -> 12 [813:66]
8323 | | | `--RPAREN -> ) [813:68]
8324 | | |--COMMA -> , [813:69]
8325 | | |--EXPR -> EXPR [814:23]
8326 | | | `--PLUS -> + [814:23]
8327 | | | |--STRING_LITERAL -> "110:15: " [814:12]
8328 | | | `--METHOD_CALL -> ( [814:40]
8329 | | | |--IDENT -> getCheckMessage [814:25]
8330 | | | |--ELIST -> ELIST [814:41]
8331 | | | | |--EXPR -> EXPR [814:41]
8332 | | | | | `--IDENT -> MSG_ERROR [814:41]
8333 | | | | |--COMMA -> , [814:50]
8334 | | | | |--EXPR -> EXPR [814:52]
8335 | | | | | `--STRING_LITERAL -> "new" [814:52]
8336 | | | | |--COMMA -> , [814:57]
8337 | | | | |--EXPR -> EXPR [814:59]
8338 | | | | | `--NUM_INT -> 14 [814:59]
8339 | | | | |--COMMA -> , [814:61]
8340 | | | | `--EXPR -> EXPR [814:63]
8341 | | | | `--NUM_INT -> 16 [814:63]
8342 | | | `--RPAREN -> ) [814:65]
8343 | | |--COMMA -> , [814:66]
8344 | | |--EXPR -> EXPR [815:23]
8345 | | | `--PLUS -> + [815:23]
8346 | | | |--STRING_LITERAL -> "113:11: " [815:12]
8347 | | | `--METHOD_CALL -> ( [815:40]
8348 | | | |--IDENT -> getCheckMessage [815:25]
8349 | | | |--ELIST -> ELIST [815:41]
8350 | | | | |--EXPR -> EXPR [815:41]
8351 | | | | | `--IDENT -> MSG_CHILD_ERROR [815:41]
8352 | | | | |--COMMA -> , [815:56]
8353 | | | | |--EXPR -> EXPR [815:58]
8354 | | | | | `--STRING_LITERAL -> "method call" [815:58]
8355 | | | | |--COMMA -> , [815:71]
8356 | | | | |--EXPR -> EXPR [815:73]
8357 | | | | | `--NUM_INT -> 10 [815:73]
8358 | | | | |--COMMA -> , [815:75]
8359 | | | | `--EXPR -> EXPR [815:77]
8360 | | | | `--NUM_INT -> 12 [815:77]
8361 | | | `--RPAREN -> ) [815:79]
8362 | | |--COMMA -> , [815:80]
8363 | | |--EXPR -> EXPR [816:23]
8364 | | | `--PLUS -> + [816:23]
8365 | | | |--STRING_LITERAL -> "118:15: " [816:12]
8366 | | | `--METHOD_CALL -> ( [816:40]
8367 | | | |--IDENT -> getCheckMessage [816:25]
8368 | | | |--ELIST -> ELIST [816:41]
8369 | | | | |--EXPR -> EXPR [816:41]
8370 | | | | | `--IDENT -> MSG_ERROR [816:41]
8371 | | | | |--COMMA -> , [816:50]
8372 | | | | |--EXPR -> EXPR [816:52]
8373 | | | | | `--STRING_LITERAL -> "new" [816:52]
8374 | | | | |--COMMA -> , [816:57]
8375 | | | | |--EXPR -> EXPR [816:59]
8376 | | | | | `--NUM_INT -> 14 [816:59]
8377 | | | | |--COMMA -> , [816:61]
8378 | | | | `--EXPR -> EXPR [816:63]
8379 | | | | `--NUM_INT -> 16 [816:63]
8380 | | | `--RPAREN -> ) [816:65]
8381 | | |--COMMA -> , [816:66]
8382 | | |--EXPR -> EXPR [817:23]
8383 | | | `--PLUS -> + [817:23]
8384 | | | |--STRING_LITERAL -> "122:11: " [817:12]
8385 | | | `--METHOD_CALL -> ( [817:40]
8386 | | | |--IDENT -> getCheckMessage [817:25]
8387 | | | |--ELIST -> ELIST [817:41]
8388 | | | | |--EXPR -> EXPR [817:41]
8389 | | | | | `--IDENT -> MSG_ERROR [817:41]
8390 | | | | |--COMMA -> , [817:50]
8391 | | | | |--EXPR -> EXPR [817:52]
8392 | | | | | `--STRING_LITERAL -> "new" [817:52]
8393 | | | | |--COMMA -> , [817:57]
8394 | | | | |--EXPR -> EXPR [817:59]
8395 | | | | | `--NUM_INT -> 10 [817:59]
8396 | | | | |--COMMA -> , [817:61]
8397 | | | | `--EXPR -> EXPR [817:63]
8398 | | | | `--NUM_INT -> 12 [817:63]
8399 | | | `--RPAREN -> ) [817:65]
8400 | | |--COMMA -> , [817:66]
8401 | | |--EXPR -> EXPR [818:23]
8402 | | | `--PLUS -> + [818:23]
8403 | | | |--STRING_LITERAL -> "126:11: " [818:12]
8404 | | | `--METHOD_CALL -> ( [818:40]
8405 | | | |--IDENT -> getCheckMessage [818:25]
8406 | | | |--ELIST -> ELIST [818:41]
8407 | | | | |--EXPR -> EXPR [818:41]
8408 | | | | | `--IDENT -> MSG_ERROR [818:41]
8409 | | | | |--COMMA -> , [818:50]
8410 | | | | |--EXPR -> EXPR [818:52]
8411 | | | | | `--STRING_LITERAL -> "new" [818:52]
8412 | | | | |--COMMA -> , [818:57]
8413 | | | | |--EXPR -> EXPR [818:59]
8414 | | | | | `--NUM_INT -> 10 [818:59]
8415 | | | | |--COMMA -> , [818:61]
8416 | | | | `--EXPR -> EXPR [818:63]
8417 | | | | `--NUM_INT -> 12 [818:63]
8418 | | | `--RPAREN -> ) [818:65]
8419 | | |--COMMA -> , [818:66]
8420 | | |--EXPR -> EXPR [819:22]
8421 | | | `--PLUS -> + [819:22]
8422 | | | |--STRING_LITERAL -> "127:7: " [819:12]
8423 | | | `--METHOD_CALL -> ( [819:39]
8424 | | | |--IDENT -> getCheckMessage [819:24]
8425 | | | |--ELIST -> ELIST [819:40]
8426 | | | | |--EXPR -> EXPR [819:40]
8427 | | | | | `--IDENT -> MSG_ERROR [819:40]
8428 | | | | |--COMMA -> , [819:49]
8429 | | | | |--EXPR -> EXPR [819:51]
8430 | | | | | `--STRING_LITERAL -> ")" [819:51]
8431 | | | | |--COMMA -> , [819:54]
8432 | | | | |--EXPR -> EXPR [819:56]
8433 | | | | | `--NUM_INT -> 6 [819:56]
8434 | | | | |--COMMA -> , [819:57]
8435 | | | | `--EXPR -> EXPR [819:59]
8436 | | | | `--NUM_INT -> 8 [819:59]
8437 | | | `--RPAREN -> ) [819:60]
8438 | | |--COMMA -> , [819:61]
8439 | | |--EXPR -> EXPR [820:22]
8440 | | | `--PLUS -> + [820:22]
8441 | | | |--STRING_LITERAL -> "131:7: " [820:12]
8442 | | | `--METHOD_CALL -> ( [820:39]
8443 | | | |--IDENT -> getCheckMessage [820:24]
8444 | | | |--ELIST -> ELIST [820:40]
8445 | | | | |--EXPR -> EXPR [820:40]
8446 | | | | | `--IDENT -> MSG_ERROR [820:40]
8447 | | | | |--COMMA -> , [820:49]
8448 | | | | |--EXPR -> EXPR [820:51]
8449 | | | | | `--STRING_LITERAL -> "method call rparen" [820:51]
8450 | | | | |--COMMA -> , [820:71]
8451 | | | | |--EXPR -> EXPR [820:73]
8452 | | | | | `--NUM_INT -> 6 [820:73]
8453 | | | | |--COMMA -> , [820:74]
8454 | | | | `--EXPR -> EXPR [820:76]
8455 | | | | `--NUM_INT -> 8 [820:76]
8456 | | | `--RPAREN -> ) [820:77]
8457 | | |--COMMA -> , [820:78]
8458 | | |--EXPR -> EXPR [821:23]
8459 | | | `--PLUS -> + [821:23]
8460 | | | |--STRING_LITERAL -> "145:11: " [821:12]
8461 | | | `--METHOD_CALL -> ( [821:40]
8462 | | | |--IDENT -> getCheckMessage [821:25]
8463 | | | |--ELIST -> ELIST [821:41]
8464 | | | | |--EXPR -> EXPR [821:41]
8465 | | | | | `--IDENT -> MSG_CHILD_ERROR [821:41]
8466 | | | | |--COMMA -> , [821:56]
8467 | | | | |--EXPR -> EXPR [821:58]
8468 | | | | | `--STRING_LITERAL -> "method call" [821:58]
8469 | | | | |--COMMA -> , [821:71]
8470 | | | | |--EXPR -> EXPR [821:73]
8471 | | | | | `--NUM_INT -> 10 [821:73]
8472 | | | | |--COMMA -> , [821:75]
8473 | | | | `--EXPR -> EXPR [821:77]
8474 | | | | `--NUM_INT -> 12 [821:77]
8475 | | | `--RPAREN -> ) [821:79]
8476 | | |--COMMA -> , [821:80]
8477 | | |--EXPR -> EXPR [822:23]
8478 | | | `--PLUS -> + [822:23]
8479 | | | |--STRING_LITERAL -> "148:11: " [822:12]
8480 | | | `--METHOD_CALL -> ( [822:40]
8481 | | | |--IDENT -> getCheckMessage [822:25]
8482 | | | |--ELIST -> ELIST [822:41]
8483 | | | | |--EXPR -> EXPR [822:41]
8484 | | | | | `--IDENT -> MSG_CHILD_ERROR [822:41]
8485 | | | | |--COMMA -> , [822:56]
8486 | | | | |--EXPR -> EXPR [822:58]
8487 | | | | | `--STRING_LITERAL -> "method call" [822:58]
8488 | | | | |--COMMA -> , [822:71]
8489 | | | | |--EXPR -> EXPR [822:73]
8490 | | | | | `--NUM_INT -> 10 [822:73]
8491 | | | | |--COMMA -> , [822:75]
8492 | | | | `--EXPR -> EXPR [822:77]
8493 | | | | `--NUM_INT -> 12 [822:77]
8494 | | | `--RPAREN -> ) [822:79]
8495 | | |--COMMA -> , [822:80]
8496 | | |--EXPR -> EXPR [823:22]
8497 | | | `--PLUS -> + [823:22]
8498 | | | |--STRING_LITERAL -> "158:7: " [823:12]
8499 | | | `--METHOD_CALL -> ( [823:39]
8500 | | | |--IDENT -> getCheckMessage [823:24]
8501 | | | |--ELIST -> ELIST [823:40]
8502 | | | | |--EXPR -> EXPR [823:40]
8503 | | | | | `--IDENT -> MSG_CHILD_ERROR [823:40]
8504 | | | | |--COMMA -> , [823:55]
8505 | | | | |--EXPR -> EXPR [823:57]
8506 | | | | | `--STRING_LITERAL -> "method call" [823:57]
8507 | | | | |--COMMA -> , [823:70]
8508 | | | | |--EXPR -> EXPR [823:72]
8509 | | | | | `--NUM_INT -> 6 [823:72]
8510 | | | | |--COMMA -> , [823:73]
8511 | | | | `--EXPR -> EXPR [823:75]
8512 | | | | `--NUM_INT -> 12 [823:75]
8513 | | | `--RPAREN -> ) [823:77]
8514 | | |--COMMA -> , [823:78]
8515 | | |--EXPR -> EXPR [824:22]
8516 | | | `--PLUS -> + [824:22]
8517 | | | |--STRING_LITERAL -> "170:5: " [824:12]
8518 | | | `--METHOD_CALL -> ( [824:39]
8519 | | | |--IDENT -> getCheckMessage [824:24]
8520 | | | |--ELIST -> ELIST [824:40]
8521 | | | | |--EXPR -> EXPR [824:40]
8522 | | | | | `--IDENT -> MSG_CHILD_ERROR [824:40]
8523 | | | | |--COMMA -> , [824:55]
8524 | | | | |--EXPR -> EXPR [824:57]
8525 | | | | | `--STRING_LITERAL -> "method def" [824:57]
8526 | | | | |--COMMA -> , [824:69]
8527 | | | | |--EXPR -> EXPR [824:71]
8528 | | | | | `--NUM_INT -> 4 [824:71]
8529 | | | | |--COMMA -> , [824:72]
8530 | | | | `--EXPR -> EXPR [824:74]
8531 | | | | `--NUM_INT -> 8 [824:74]
8532 | | | `--RPAREN -> ) [824:75]
8533 | | |--COMMA -> , [824:76]
8534 | | |--EXPR -> EXPR [825:22]
8535 | | | `--PLUS -> + [825:22]
8536 | | | |--STRING_LITERAL -> "175:5: " [825:12]
8537 | | | `--METHOD_CALL -> ( [825:39]
8538 | | | |--IDENT -> getCheckMessage [825:24]
8539 | | | |--ELIST -> ELIST [825:40]
8540 | | | | |--EXPR -> EXPR [825:40]
8541 | | | | | `--IDENT -> MSG_CHILD_ERROR [825:40]
8542 | | | | |--COMMA -> , [825:55]
8543 | | | | |--EXPR -> EXPR [825:57]
8544 | | | | | `--STRING_LITERAL -> "method def" [825:57]
8545 | | | | |--COMMA -> , [825:69]
8546 | | | | |--EXPR -> EXPR [825:71]
8547 | | | | | `--NUM_INT -> 4 [825:71]
8548 | | | | |--COMMA -> , [825:72]
8549 | | | | `--EXPR -> EXPR [825:74]
8550 | | | | `--NUM_INT -> 8 [825:74]
8551 | | | `--RPAREN -> ) [825:75]
8552 | | |--COMMA -> , [825:76]
8553 | | |--EXPR -> EXPR [826:22]
8554 | | | `--PLUS -> + [826:22]
8555 | | | |--STRING_LITERAL -> "179:1: " [826:12]
8556 | | | `--METHOD_CALL -> ( [826:39]
8557 | | | |--IDENT -> getCheckMessage [826:24]
8558 | | | |--ELIST -> ELIST [826:40]
8559 | | | | |--EXPR -> EXPR [826:40]
8560 | | | | | `--IDENT -> MSG_ERROR [826:40]
8561 | | | | |--COMMA -> , [826:49]
8562 | | | | |--EXPR -> EXPR [826:51]
8563 | | | | | `--STRING_LITERAL -> "int" [826:51]
8564 | | | | |--COMMA -> , [826:56]
8565 | | | | |--EXPR -> EXPR [826:58]
8566 | | | | | `--NUM_INT -> 0 [826:58]
8567 | | | | |--COMMA -> , [826:59]
8568 | | | | `--EXPR -> EXPR [826:61]
8569 | | | | `--NUM_INT -> 8 [826:61]
8570 | | | `--RPAREN -> ) [826:62]
8571 | | |--COMMA -> , [826:63]
8572 | | |--EXPR -> EXPR [827:22]
8573 | | | `--PLUS -> + [827:22]
8574 | | | |--STRING_LITERAL -> "180:5: " [827:12]
8575 | | | `--METHOD_CALL -> ( [827:39]
8576 | | | |--IDENT -> getCheckMessage [827:24]
8577 | | | |--ELIST -> ELIST [827:40]
8578 | | | | |--EXPR -> EXPR [827:40]
8579 | | | | | `--IDENT -> MSG_ERROR [827:40]
8580 | | | | |--COMMA -> , [827:49]
8581 | | | | |--EXPR -> EXPR [827:51]
8582 | | | | | `--STRING_LITERAL -> "method9" [827:51]
8583 | | | | |--COMMA -> , [827:60]
8584 | | | | |--EXPR -> EXPR [827:62]
8585 | | | | | `--NUM_INT -> 4 [827:62]
8586 | | | | |--COMMA -> , [827:63]
8587 | | | | `--EXPR -> EXPR [827:65]
8588 | | | | `--NUM_INT -> 8 [827:65]
8589 | | | `--RPAREN -> ) [827:66]
8590 | | |--COMMA -> , [827:67]
8591 | | |--EXPR -> EXPR [828:23]
8592 | | | `--PLUS -> + [828:23]
8593 | | | |--STRING_LITERAL -> "190:13: " [828:12]
8594 | | | `--METHOD_CALL -> ( [828:40]
8595 | | | |--IDENT -> getCheckMessage [828:25]
8596 | | | |--ELIST -> ELIST [828:41]
8597 | | | | |--EXPR -> EXPR [828:41]
8598 | | | | | `--IDENT -> MSG_CHILD_ERROR [828:41]
8599 | | | | |--COMMA -> , [828:56]
8600 | | | | |--EXPR -> EXPR [828:58]
8601 | | | | | `--STRING_LITERAL -> "method def" [828:58]
8602 | | | | |--COMMA -> , [828:70]
8603 | | | | |--EXPR -> EXPR [828:72]
8604 | | | | | `--NUM_INT -> 12 [828:72]
8605 | | | | |--COMMA -> , [828:74]
8606 | | | | `--EXPR -> EXPR [828:76]
8607 | | | | `--NUM_INT -> 8 [828:76]
8608 | | | `--RPAREN -> ) [828:77]
8609 | | |--COMMA -> , [828:78]
8610 | | `--RCURLY -> } [829:8]
8611 | |--SEMI -> ; [829:9]
8612 | |--EXPR -> EXPR [830:19]
8613 | | `--METHOD_CALL -> ( [830:19]
8614 | | |--IDENT -> verifyWarns [830:8]
8615 | | |--ELIST -> ELIST [830:20]
8616 | | | |--EXPR -> EXPR [830:20]
8617 | | | | `--IDENT -> checkConfig [830:20]
8618 | | | |--COMMA -> , [830:31]
8619 | | | |--EXPR -> EXPR [830:33]
8620 | | | | `--IDENT -> fileName [830:33]
8621 | | | |--COMMA -> , [830:41]
8622 | | | `--EXPR -> EXPR [830:43]
8623 | | | `--IDENT -> expected [830:43]
8624 | | `--RPAREN -> ) [830:51]
8625 | |--SEMI -> ; [830:52]
8626 | `--RCURLY -> } [831:4]
8627 |--METHOD_DEF -> METHOD_DEF [833:4]
8628 | |--MODIFIERS -> MODIFIERS [833:4]
8629 | | |--ANNOTATION -> ANNOTATION [833:4]
8630 | | | |--AT -> @ [833:4]
8631 | | | `--IDENT -> Test [833:5]
8632 | | `--LITERAL_PUBLIC -> public [834:4]
8633 | |--TYPE -> TYPE [834:11]
8634 | | `--LITERAL_VOID -> void [834:11]
8635 | |--IDENT -> testAlternativeGoogleStyleSwitchCaseAndEnums [834:16]
8636 | |--LPAREN -> ( [834:60]
8637 | |--PARAMETERS -> PARAMETERS [834:61]
8638 | |--RPAREN -> ) [834:61]
8639 | |--LITERAL_THROWS -> throws [835:12]
8640 | | `--IDENT -> Exception [835:19]
8641 | `--SLIST -> { [835:29]
8642 | |--VARIABLE_DEF -> VARIABLE_DEF [836:8]
8643 | | |--MODIFIERS -> MODIFIERS [836:8]
8644 | | | `--FINAL -> final [836:8]
8645 | | |--TYPE -> TYPE [836:14]
8646 | | | `--IDENT -> DefaultConfiguration [836:14]
8647 | | |--IDENT -> checkConfig [836:35]
8648 | | `--ASSIGN -> = [836:47]
8649 | | `--EXPR -> EXPR [836:67]
8650 | | `--METHOD_CALL -> ( [836:67]
8651 | | |--IDENT -> createModuleConfig [836:49]
8652 | | |--ELIST -> ELIST [836:84]
8653 | | | `--EXPR -> EXPR [836:84]
8654 | | | `--DOT -> . [836:84]
8655 | | | |--IDENT -> IndentationCheck [836:68]
8656 | | | `--LITERAL_CLASS -> class [836:85]
8657 | | `--RPAREN -> ) [836:90]
8658 | |--SEMI -> ; [836:91]
8659 | |--EXPR -> EXPR [838:32]
8660 | | `--METHOD_CALL -> ( [838:32]
8661 | | |--DOT -> . [838:19]
8662 | | | |--IDENT -> checkConfig [838:8]
8663 | | | `--IDENT -> addAttribute [838:20]
8664 | | |--ELIST -> ELIST [838:33]
8665 | | | |--EXPR -> EXPR [838:33]
8666 | | | | `--STRING_LITERAL -> "arrayInitIndent" [838:33]
8667 | | | |--COMMA -> , [838:50]
8668 | | | `--EXPR -> EXPR [838:52]
8669 | | | `--STRING_LITERAL -> "4" [838:52]
8670 | | `--RPAREN -> ) [838:55]
8671 | |--SEMI -> ; [838:56]
8672 | |--EXPR -> EXPR [839:32]
8673 | | `--METHOD_CALL -> ( [839:32]
8674 | | |--DOT -> . [839:19]
8675 | | | |--IDENT -> checkConfig [839:8]
8676 | | | `--IDENT -> addAttribute [839:20]
8677 | | |--ELIST -> ELIST [839:33]
8678 | | | |--EXPR -> EXPR [839:33]
8679 | | | | `--STRING_LITERAL -> "basicOffset" [839:33]
8680 | | | |--COMMA -> , [839:46]
8681 | | | `--EXPR -> EXPR [839:48]
8682 | | | `--STRING_LITERAL -> "2" [839:48]
8683 | | `--RPAREN -> ) [839:51]
8684 | |--SEMI -> ; [839:52]
8685 | |--EXPR -> EXPR [840:32]
8686 | | `--METHOD_CALL -> ( [840:32]
8687 | | |--DOT -> . [840:19]
8688 | | | |--IDENT -> checkConfig [840:8]
8689 | | | `--IDENT -> addAttribute [840:20]
8690 | | |--ELIST -> ELIST [840:33]
8691 | | | |--EXPR -> EXPR [840:33]
8692 | | | | `--STRING_LITERAL -> "braceAdjustment" [840:33]
8693 | | | |--COMMA -> , [840:50]
8694 | | | `--EXPR -> EXPR [840:52]
8695 | | | `--STRING_LITERAL -> "2" [840:52]
8696 | | `--RPAREN -> ) [840:55]
8697 | |--SEMI -> ; [840:56]
8698 | |--EXPR -> EXPR [841:32]
8699 | | `--METHOD_CALL -> ( [841:32]
8700 | | |--DOT -> . [841:19]
8701 | | | |--IDENT -> checkConfig [841:8]
8702 | | | `--IDENT -> addAttribute [841:20]
8703 | | |--ELIST -> ELIST [841:33]
8704 | | | |--EXPR -> EXPR [841:33]
8705 | | | | `--STRING_LITERAL -> "caseIndent" [841:33]
8706 | | | |--COMMA -> , [841:45]
8707 | | | `--EXPR -> EXPR [841:47]
8708 | | | `--STRING_LITERAL -> "2" [841:47]
8709 | | `--RPAREN -> ) [841:50]
8710 | |--SEMI -> ; [841:51]
8711 | |--EXPR -> EXPR [842:32]
8712 | | `--METHOD_CALL -> ( [842:32]
8713 | | |--DOT -> . [842:19]
8714 | | | |--IDENT -> checkConfig [842:8]
8715 | | | `--IDENT -> addAttribute [842:20]
8716 | | |--ELIST -> ELIST [842:33]
8717 | | | |--EXPR -> EXPR [842:33]
8718 | | | | `--STRING_LITERAL -> "forceStrictCondition" [842:33]
8719 | | | |--COMMA -> , [842:55]
8720 | | | `--EXPR -> EXPR [842:57]
8721 | | | `--STRING_LITERAL -> "false" [842:57]
8722 | | `--RPAREN -> ) [842:64]
8723 | |--SEMI -> ; [842:65]
8724 | |--EXPR -> EXPR [843:32]
8725 | | `--METHOD_CALL -> ( [843:32]
8726 | | |--DOT -> . [843:19]
8727 | | | |--IDENT -> checkConfig [843:8]
8728 | | | `--IDENT -> addAttribute [843:20]
8729 | | |--ELIST -> ELIST [843:33]
8730 | | | |--EXPR -> EXPR [843:33]
8731 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [843:33]
8732 | | | |--COMMA -> , [843:58]
8733 | | | `--EXPR -> EXPR [843:60]
8734 | | | `--STRING_LITERAL -> "4" [843:60]
8735 | | `--RPAREN -> ) [843:63]
8736 | |--SEMI -> ; [843:64]
8737 | |--EXPR -> EXPR [844:32]
8738 | | `--METHOD_CALL -> ( [844:32]
8739 | | |--DOT -> . [844:19]
8740 | | | |--IDENT -> checkConfig [844:8]
8741 | | | `--IDENT -> addAttribute [844:20]
8742 | | |--ELIST -> ELIST [844:33]
8743 | | | |--EXPR -> EXPR [844:33]
8744 | | | | `--STRING_LITERAL -> "tabWidth" [844:33]
8745 | | | |--COMMA -> , [844:43]
8746 | | | `--EXPR -> EXPR [844:45]
8747 | | | `--STRING_LITERAL -> "4" [844:45]
8748 | | `--RPAREN -> ) [844:48]
8749 | |--SEMI -> ; [844:49]
8750 | |--EXPR -> EXPR [845:32]
8751 | | `--METHOD_CALL -> ( [845:32]
8752 | | |--DOT -> . [845:19]
8753 | | | |--IDENT -> checkConfig [845:8]
8754 | | | `--IDENT -> addAttribute [845:20]
8755 | | |--ELIST -> ELIST [845:33]
8756 | | | |--EXPR -> EXPR [845:33]
8757 | | | | `--STRING_LITERAL -> "throwsIndent" [845:33]
8758 | | | |--COMMA -> , [845:47]
8759 | | | `--EXPR -> EXPR [845:49]
8760 | | | `--STRING_LITERAL -> "4" [845:49]
8761 | | `--RPAREN -> ) [845:52]
8762 | |--SEMI -> ; [845:53]
8763 | |--VARIABLE_DEF -> VARIABLE_DEF [846:8]
8764 | | |--MODIFIERS -> MODIFIERS [846:8]
8765 | | | `--FINAL -> final [846:8]
8766 | | |--TYPE -> TYPE [846:14]
8767 | | | `--IDENT -> String [846:14]
8768 | | |--IDENT -> fileName [846:21]
8769 | | `--ASSIGN -> = [846:30]
8770 | | `--EXPR -> EXPR [846:39]
8771 | | `--METHOD_CALL -> ( [846:39]
8772 | | |--IDENT -> getPath [846:32]
8773 | | |--ELIST -> ELIST [846:40]
8774 | | | `--EXPR -> EXPR [846:40]
8775 | | | `--STRING_LITERAL -> "InputIndentationSwitchCasesAndEnums.java" [846:40]
8776 | | `--RPAREN -> ) [846:82]
8777 | |--SEMI -> ; [846:83]
8778 | |--VARIABLE_DEF -> VARIABLE_DEF [847:8]
8779 | | |--MODIFIERS -> MODIFIERS [847:8]
8780 | | | `--FINAL -> final [847:8]
8781 | | |--TYPE -> TYPE [847:20]
8782 | | | `--ARRAY_DECLARATOR -> [ [847:20]
8783 | | | |--IDENT -> String [847:14]
8784 | | | `--RBRACK -> ] [847:21]
8785 | | |--IDENT -> expected [847:23]
8786 | | `--ASSIGN -> = [847:32]
8787 | | `--ARRAY_INIT -> { [847:34]
8788 | | |--EXPR -> EXPR [848:21]
8789 | | | `--PLUS -> + [848:21]
8790 | | | |--STRING_LITERAL -> "18:7: " [848:12]
8791 | | | `--METHOD_CALL -> ( [848:38]
8792 | | | |--IDENT -> getCheckMessage [848:23]
8793 | | | |--ELIST -> ELIST [848:39]
8794 | | | | |--EXPR -> EXPR [848:39]
8795 | | | | | `--IDENT -> MSG_CHILD_ERROR [848:39]
8796 | | | | |--COMMA -> , [848:54]
8797 | | | | |--EXPR -> EXPR [848:56]
8798 | | | | | `--STRING_LITERAL -> "block" [848:56]
8799 | | | | |--COMMA -> , [848:63]
8800 | | | | |--EXPR -> EXPR [848:65]
8801 | | | | | `--NUM_INT -> 6 [848:65]
8802 | | | | |--COMMA -> , [848:66]
8803 | | | | `--EXPR -> EXPR [848:68]
8804 | | | | `--NUM_INT -> 4 [848:68]
8805 | | | `--RPAREN -> ) [848:69]
8806 | | |--COMMA -> , [848:70]
8807 | | |--EXPR -> EXPR [849:21]
8808 | | | `--PLUS -> + [849:21]
8809 | | | |--STRING_LITERAL -> "35:7: " [849:12]
8810 | | | `--METHOD_CALL -> ( [849:38]
8811 | | | |--IDENT -> getCheckMessage [849:23]
8812 | | | |--ELIST -> ELIST [849:39]
8813 | | | | |--EXPR -> EXPR [849:39]
8814 | | | | | `--IDENT -> MSG_ERROR [849:39]
8815 | | | | |--COMMA -> , [849:48]
8816 | | | | |--EXPR -> EXPR [849:50]
8817 | | | | | `--STRING_LITERAL -> "block lcurly" [849:50]
8818 | | | | |--COMMA -> , [849:64]
8819 | | | | |--EXPR -> EXPR [849:66]
8820 | | | | | `--NUM_INT -> 6 [849:66]
8821 | | | | |--COMMA -> , [849:67]
8822 | | | | `--EXPR -> EXPR [849:69]
8823 | | | | `--NUM_INT -> 8 [849:69]
8824 | | | `--RPAREN -> ) [849:70]
8825 | | |--COMMA -> , [849:71]
8826 | | |--EXPR -> EXPR [850:22]
8827 | | | `--PLUS -> + [850:22]
8828 | | | |--STRING_LITERAL -> "38:11: " [850:12]
8829 | | | `--METHOD_CALL -> ( [850:39]
8830 | | | |--IDENT -> getCheckMessage [850:24]
8831 | | | |--ELIST -> ELIST [850:40]
8832 | | | | |--EXPR -> EXPR [850:40]
8833 | | | | | `--IDENT -> MSG_ERROR [850:40]
8834 | | | | |--COMMA -> , [850:49]
8835 | | | | |--EXPR -> EXPR [850:51]
8836 | | | | | `--STRING_LITERAL -> "block rcurly" [850:51]
8837 | | | | |--COMMA -> , [850:65]
8838 | | | | |--EXPR -> EXPR [850:67]
8839 | | | | | `--NUM_INT -> 10 [850:67]
8840 | | | | |--COMMA -> , [850:69]
8841 | | | | `--EXPR -> EXPR [850:71]
8842 | | | | `--NUM_INT -> 8 [850:71]
8843 | | | `--RPAREN -> ) [850:72]
8844 | | |--COMMA -> , [850:73]
8845 | | |--EXPR -> EXPR [851:21]
8846 | | | `--PLUS -> + [851:21]
8847 | | | |--STRING_LITERAL -> "54:5: " [851:12]
8848 | | | `--METHOD_CALL -> ( [851:38]
8849 | | | |--IDENT -> getCheckMessage [851:23]
8850 | | | |--ELIST -> ELIST [851:39]
8851 | | | | |--EXPR -> EXPR [851:39]
8852 | | | | | `--IDENT -> MSG_ERROR [851:39]
8853 | | | | |--COMMA -> , [851:48]
8854 | | | | |--EXPR -> EXPR [851:50]
8855 | | | | | `--STRING_LITERAL -> "block lcurly" [851:50]
8856 | | | | |--COMMA -> , [851:64]
8857 | | | | |--EXPR -> EXPR [851:66]
8858 | | | | | `--NUM_INT -> 4 [851:66]
8859 | | | | |--COMMA -> , [851:67]
8860 | | | | `--EXPR -> EXPR [851:69]
8861 | | | | `--NUM_INT -> 2 [851:69]
8862 | | | `--RPAREN -> ) [851:70]
8863 | | |--COMMA -> , [851:71]
8864 | | |--EXPR -> EXPR [852:21]
8865 | | | `--PLUS -> + [852:21]
8866 | | | |--STRING_LITERAL -> "55:3: " [852:12]
8867 | | | `--METHOD_CALL -> ( [852:38]
8868 | | | |--IDENT -> getCheckMessage [852:23]
8869 | | | |--ELIST -> ELIST [852:39]
8870 | | | | |--EXPR -> EXPR [852:39]
8871 | | | | | `--IDENT -> MSG_CHILD_ERROR [852:39]
8872 | | | | |--COMMA -> , [852:54]
8873 | | | | |--EXPR -> EXPR [852:56]
8874 | | | | | `--STRING_LITERAL -> "block" [852:56]
8875 | | | | |--COMMA -> , [852:63]
8876 | | | | |--EXPR -> EXPR [852:65]
8877 | | | | | `--NUM_INT -> 2 [852:65]
8878 | | | | |--COMMA -> , [852:66]
8879 | | | | `--EXPR -> EXPR [852:68]
8880 | | | | `--NUM_INT -> 4 [852:68]
8881 | | | `--RPAREN -> ) [852:69]
8882 | | |--COMMA -> , [852:70]
8883 | | `--RCURLY -> } [853:8]
8884 | |--SEMI -> ; [853:9]
8885 | |--EXPR -> EXPR [854:19]
8886 | | `--METHOD_CALL -> ( [854:19]
8887 | | |--IDENT -> verifyWarns [854:8]
8888 | | |--ELIST -> ELIST [854:20]
8889 | | | |--EXPR -> EXPR [854:20]
8890 | | | | `--IDENT -> checkConfig [854:20]
8891 | | | |--COMMA -> , [854:31]
8892 | | | |--EXPR -> EXPR [854:33]
8893 | | | | `--IDENT -> fileName [854:33]
8894 | | | |--COMMA -> , [854:41]
8895 | | | `--EXPR -> EXPR [854:43]
8896 | | | `--IDENT -> expected [854:43]
8897 | | `--RPAREN -> ) [854:51]
8898 | |--SEMI -> ; [854:52]
8899 | `--RCURLY -> } [855:4]
8900 |--METHOD_DEF -> METHOD_DEF [857:4]
8901 | |--MODIFIERS -> MODIFIERS [857:4]
8902 | | |--ANNOTATION -> ANNOTATION [857:4]
8903 | | | |--AT -> @ [857:4]
8904 | | | `--IDENT -> Test [857:5]
8905 | | `--LITERAL_PUBLIC -> public [858:4]
8906 | |--TYPE -> TYPE [858:11]
8907 | | `--LITERAL_VOID -> void [858:11]
8908 | |--IDENT -> testInvalidSwitchWithChecker [858:16]
8909 | |--LPAREN -> ( [858:44]
8910 | |--PARAMETERS -> PARAMETERS [858:45]
8911 | |--RPAREN -> ) [858:45]
8912 | |--LITERAL_THROWS -> throws [859:12]
8913 | | `--IDENT -> Exception [859:19]
8914 | `--SLIST -> { [859:29]
8915 | |--VARIABLE_DEF -> VARIABLE_DEF [860:8]
8916 | | |--MODIFIERS -> MODIFIERS [860:8]
8917 | | | `--FINAL -> final [860:8]
8918 | | |--TYPE -> TYPE [860:14]
8919 | | | `--IDENT -> DefaultConfiguration [860:14]
8920 | | |--IDENT -> checkConfig [860:35]
8921 | | `--ASSIGN -> = [860:47]
8922 | | `--EXPR -> EXPR [860:67]
8923 | | `--METHOD_CALL -> ( [860:67]
8924 | | |--IDENT -> createModuleConfig [860:49]
8925 | | |--ELIST -> ELIST [860:84]
8926 | | | `--EXPR -> EXPR [860:84]
8927 | | | `--DOT -> . [860:84]
8928 | | | |--IDENT -> IndentationCheck [860:68]
8929 | | | `--LITERAL_CLASS -> class [860:85]
8930 | | `--RPAREN -> ) [860:90]
8931 | |--SEMI -> ; [860:91]
8932 | |--EXPR -> EXPR [862:32]
8933 | | `--METHOD_CALL -> ( [862:32]
8934 | | |--DOT -> . [862:19]
8935 | | | |--IDENT -> checkConfig [862:8]
8936 | | | `--IDENT -> addAttribute [862:20]
8937 | | |--ELIST -> ELIST [862:33]
8938 | | | |--EXPR -> EXPR [862:33]
8939 | | | | `--STRING_LITERAL -> "arrayInitIndent" [862:33]
8940 | | | |--COMMA -> , [862:50]
8941 | | | `--EXPR -> EXPR [862:52]
8942 | | | `--STRING_LITERAL -> "4" [862:52]
8943 | | `--RPAREN -> ) [862:55]
8944 | |--SEMI -> ; [862:56]
8945 | |--EXPR -> EXPR [863:32]
8946 | | `--METHOD_CALL -> ( [863:32]
8947 | | |--DOT -> . [863:19]
8948 | | | |--IDENT -> checkConfig [863:8]
8949 | | | `--IDENT -> addAttribute [863:20]
8950 | | |--ELIST -> ELIST [863:33]
8951 | | | |--EXPR -> EXPR [863:33]
8952 | | | | `--STRING_LITERAL -> "basicOffset" [863:33]
8953 | | | |--COMMA -> , [863:46]
8954 | | | `--EXPR -> EXPR [863:48]
8955 | | | `--STRING_LITERAL -> "4" [863:48]
8956 | | `--RPAREN -> ) [863:51]
8957 | |--SEMI -> ; [863:52]
8958 | |--EXPR -> EXPR [864:32]
8959 | | `--METHOD_CALL -> ( [864:32]
8960 | | |--DOT -> . [864:19]
8961 | | | |--IDENT -> checkConfig [864:8]
8962 | | | `--IDENT -> addAttribute [864:20]
8963 | | |--ELIST -> ELIST [864:33]
8964 | | | |--EXPR -> EXPR [864:33]
8965 | | | | `--STRING_LITERAL -> "braceAdjustment" [864:33]
8966 | | | |--COMMA -> , [864:50]
8967 | | | `--EXPR -> EXPR [864:52]
8968 | | | `--STRING_LITERAL -> "0" [864:52]
8969 | | `--RPAREN -> ) [864:55]
8970 | |--SEMI -> ; [864:56]
8971 | |--EXPR -> EXPR [865:32]
8972 | | `--METHOD_CALL -> ( [865:32]
8973 | | |--DOT -> . [865:19]
8974 | | | |--IDENT -> checkConfig [865:8]
8975 | | | `--IDENT -> addAttribute [865:20]
8976 | | |--ELIST -> ELIST [865:33]
8977 | | | |--EXPR -> EXPR [865:33]
8978 | | | | `--STRING_LITERAL -> "caseIndent" [865:33]
8979 | | | |--COMMA -> , [865:45]
8980 | | | `--EXPR -> EXPR [865:47]
8981 | | | `--STRING_LITERAL -> "4" [865:47]
8982 | | `--RPAREN -> ) [865:50]
8983 | |--SEMI -> ; [865:51]
8984 | |--EXPR -> EXPR [866:32]
8985 | | `--METHOD_CALL -> ( [866:32]
8986 | | |--DOT -> . [866:19]
8987 | | | |--IDENT -> checkConfig [866:8]
8988 | | | `--IDENT -> addAttribute [866:20]
8989 | | |--ELIST -> ELIST [866:33]
8990 | | | |--EXPR -> EXPR [866:33]
8991 | | | | `--STRING_LITERAL -> "forceStrictCondition" [866:33]
8992 | | | |--COMMA -> , [866:55]
8993 | | | `--EXPR -> EXPR [866:57]
8994 | | | `--STRING_LITERAL -> "false" [866:57]
8995 | | `--RPAREN -> ) [866:64]
8996 | |--SEMI -> ; [866:65]
8997 | |--EXPR -> EXPR [867:32]
8998 | | `--METHOD_CALL -> ( [867:32]
8999 | | |--DOT -> . [867:19]
9000 | | | |--IDENT -> checkConfig [867:8]
9001 | | | `--IDENT -> addAttribute [867:20]
9002 | | |--ELIST -> ELIST [867:33]
9003 | | | |--EXPR -> EXPR [867:33]
9004 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [867:33]
9005 | | | |--COMMA -> , [867:58]
9006 | | | `--EXPR -> EXPR [867:60]
9007 | | | `--STRING_LITERAL -> "4" [867:60]
9008 | | `--RPAREN -> ) [867:63]
9009 | |--SEMI -> ; [867:64]
9010 | |--EXPR -> EXPR [868:32]
9011 | | `--METHOD_CALL -> ( [868:32]
9012 | | |--DOT -> . [868:19]
9013 | | | |--IDENT -> checkConfig [868:8]
9014 | | | `--IDENT -> addAttribute [868:20]
9015 | | |--ELIST -> ELIST [868:33]
9016 | | | |--EXPR -> EXPR [868:33]
9017 | | | | `--STRING_LITERAL -> "tabWidth" [868:33]
9018 | | | |--COMMA -> , [868:43]
9019 | | | `--EXPR -> EXPR [868:45]
9020 | | | `--STRING_LITERAL -> "4" [868:45]
9021 | | `--RPAREN -> ) [868:48]
9022 | |--SEMI -> ; [868:49]
9023 | |--EXPR -> EXPR [869:32]
9024 | | `--METHOD_CALL -> ( [869:32]
9025 | | |--DOT -> . [869:19]
9026 | | | |--IDENT -> checkConfig [869:8]
9027 | | | `--IDENT -> addAttribute [869:20]
9028 | | |--ELIST -> ELIST [869:33]
9029 | | | |--EXPR -> EXPR [869:33]
9030 | | | | `--STRING_LITERAL -> "throwsIndent" [869:33]
9031 | | | |--COMMA -> , [869:47]
9032 | | | `--EXPR -> EXPR [869:49]
9033 | | | `--STRING_LITERAL -> "4" [869:49]
9034 | | `--RPAREN -> ) [869:52]
9035 | |--SEMI -> ; [869:53]
9036 | |--VARIABLE_DEF -> VARIABLE_DEF [870:8]
9037 | | |--MODIFIERS -> MODIFIERS [870:8]
9038 | | | `--FINAL -> final [870:8]
9039 | | |--TYPE -> TYPE [870:14]
9040 | | | `--IDENT -> String [870:14]
9041 | | |--IDENT -> fileName [870:21]
9042 | | `--ASSIGN -> = [870:30]
9043 | | `--EXPR -> EXPR [870:39]
9044 | | `--METHOD_CALL -> ( [870:39]
9045 | | |--IDENT -> getPath [870:32]
9046 | | |--ELIST -> ELIST [870:40]
9047 | | | `--EXPR -> EXPR [870:40]
9048 | | | `--STRING_LITERAL -> "InputIndentationInvalidSwitchIndent.java" [870:40]
9049 | | `--RPAREN -> ) [870:82]
9050 | |--SEMI -> ; [870:83]
9051 | |--VARIABLE_DEF -> VARIABLE_DEF [871:8]
9052 | | |--MODIFIERS -> MODIFIERS [871:8]
9053 | | | `--FINAL -> final [871:8]
9054 | | |--TYPE -> TYPE [871:20]
9055 | | | `--ARRAY_DECLARATOR -> [ [871:20]
9056 | | | |--IDENT -> String [871:14]
9057 | | | `--RBRACK -> ] [871:21]
9058 | | |--IDENT -> expected [871:23]
9059 | | `--ASSIGN -> = [871:32]
9060 | | `--ARRAY_INIT -> { [871:34]
9061 | | |--EXPR -> EXPR [872:21]
9062 | | | `--PLUS -> + [872:21]
9063 | | | |--STRING_LITERAL -> "30:7: " [872:12]
9064 | | | `--METHOD_CALL -> ( [872:38]
9065 | | | |--IDENT -> getCheckMessage [872:23]
9066 | | | |--ELIST -> ELIST [872:39]
9067 | | | | |--EXPR -> EXPR [872:39]
9068 | | | | | `--IDENT -> MSG_ERROR [872:39]
9069 | | | | |--COMMA -> , [872:48]
9070 | | | | |--EXPR -> EXPR [872:50]
9071 | | | | | `--STRING_LITERAL -> "switch" [872:50]
9072 | | | | |--COMMA -> , [872:58]
9073 | | | | |--EXPR -> EXPR [872:60]
9074 | | | | | `--NUM_INT -> 6 [872:60]
9075 | | | | |--COMMA -> , [872:61]
9076 | | | | `--EXPR -> EXPR [872:63]
9077 | | | | `--NUM_INT -> 8 [872:63]
9078 | | | `--RPAREN -> ) [872:64]
9079 | | |--COMMA -> , [872:65]
9080 | | |--EXPR -> EXPR [873:22]
9081 | | | `--PLUS -> + [873:22]
9082 | | | |--STRING_LITERAL -> "32:11: " [873:12]
9083 | | | `--METHOD_CALL -> ( [873:39]
9084 | | | |--IDENT -> getCheckMessage [873:24]
9085 | | | |--ELIST -> ELIST [873:40]
9086 | | | | |--EXPR -> EXPR [873:40]
9087 | | | | | `--IDENT -> MSG_CHILD_ERROR [873:40]
9088 | | | | |--COMMA -> , [873:55]
9089 | | | | |--EXPR -> EXPR [873:57]
9090 | | | | | `--STRING_LITERAL -> "case" [873:57]
9091 | | | | |--COMMA -> , [873:63]
9092 | | | | |--EXPR -> EXPR [873:65]
9093 | | | | | `--NUM_INT -> 10 [873:65]
9094 | | | | |--COMMA -> , [873:67]
9095 | | | | `--EXPR -> EXPR [873:69]
9096 | | | | `--NUM_INT -> 12 [873:69]
9097 | | | `--RPAREN -> ) [873:71]
9098 | | |--COMMA -> , [873:72]
9099 | | |--EXPR -> EXPR [874:22]
9100 | | | `--PLUS -> + [874:22]
9101 | | | |--STRING_LITERAL -> "33:15: " [874:12]
9102 | | | `--METHOD_CALL -> ( [874:39]
9103 | | | |--IDENT -> getCheckMessage [874:24]
9104 | | | |--ELIST -> ELIST [874:40]
9105 | | | | |--EXPR -> EXPR [874:40]
9106 | | | | | `--IDENT -> MSG_CHILD_ERROR [874:40]
9107 | | | | |--COMMA -> , [874:55]
9108 | | | | |--EXPR -> EXPR [874:57]
9109 | | | | | `--STRING_LITERAL -> "block" [874:57]
9110 | | | | |--COMMA -> , [874:64]
9111 | | | | |--EXPR -> EXPR [874:66]
9112 | | | | | `--NUM_INT -> 14 [874:66]
9113 | | | | |--COMMA -> , [874:68]
9114 | | | | `--EXPR -> EXPR [874:70]
9115 | | | | `--NUM_INT -> 16 [874:70]
9116 | | | `--RPAREN -> ) [874:72]
9117 | | |--COMMA -> , [874:73]
9118 | | |--EXPR -> EXPR [875:22]
9119 | | | `--PLUS -> + [875:22]
9120 | | | |--STRING_LITERAL -> "37:15: " [875:12]
9121 | | | `--METHOD_CALL -> ( [875:39]
9122 | | | |--IDENT -> getCheckMessage [875:24]
9123 | | | |--ELIST -> ELIST [875:40]
9124 | | | | |--EXPR -> EXPR [875:40]
9125 | | | | | `--IDENT -> MSG_CHILD_ERROR [875:40]
9126 | | | | |--COMMA -> , [875:55]
9127 | | | | |--EXPR -> EXPR [875:57]
9128 | | | | | `--STRING_LITERAL -> "block" [875:57]
9129 | | | | |--COMMA -> , [875:64]
9130 | | | | |--EXPR -> EXPR [875:66]
9131 | | | | | `--NUM_INT -> 14 [875:66]
9132 | | | | |--COMMA -> , [875:68]
9133 | | | | `--EXPR -> EXPR [875:70]
9134 | | | | `--NUM_INT -> 16 [875:70]
9135 | | | `--RPAREN -> ) [875:72]
9136 | | |--COMMA -> , [875:73]
9137 | | |--EXPR -> EXPR [876:22]
9138 | | | `--PLUS -> + [876:22]
9139 | | | |--STRING_LITERAL -> "39:15: " [876:12]
9140 | | | `--METHOD_CALL -> ( [876:39]
9141 | | | |--IDENT -> getCheckMessage [876:24]
9142 | | | |--ELIST -> ELIST [876:40]
9143 | | | | |--EXPR -> EXPR [876:40]
9144 | | | | | `--IDENT -> MSG_CHILD_ERROR [876:40]
9145 | | | | |--COMMA -> , [876:55]
9146 | | | | |--EXPR -> EXPR [876:57]
9147 | | | | | `--STRING_LITERAL -> "case" [876:57]
9148 | | | | |--COMMA -> , [876:63]
9149 | | | | |--EXPR -> EXPR [876:65]
9150 | | | | | `--NUM_INT -> 14 [876:65]
9151 | | | | |--COMMA -> , [876:67]
9152 | | | | `--EXPR -> EXPR [876:69]
9153 | | | | `--NUM_INT -> 12 [876:69]
9154 | | | `--RPAREN -> ) [876:71]
9155 | | |--COMMA -> , [876:72]
9156 | | |--EXPR -> EXPR [877:22]
9157 | | | `--PLUS -> + [877:22]
9158 | | | |--STRING_LITERAL -> "40:11: " [877:12]
9159 | | | `--METHOD_CALL -> ( [877:39]
9160 | | | |--IDENT -> getCheckMessage [877:24]
9161 | | | |--ELIST -> ELIST [877:40]
9162 | | | | |--EXPR -> EXPR [877:40]
9163 | | | | | `--IDENT -> MSG_CHILD_ERROR [877:40]
9164 | | | | |--COMMA -> , [877:55]
9165 | | | | |--EXPR -> EXPR [877:57]
9166 | | | | | `--STRING_LITERAL -> "case" [877:57]
9167 | | | | |--COMMA -> , [877:63]
9168 | | | | |--EXPR -> EXPR [877:65]
9169 | | | | | `--NUM_INT -> 10 [877:65]
9170 | | | | |--COMMA -> , [877:67]
9171 | | | | `--EXPR -> EXPR [877:69]
9172 | | | | `--NUM_INT -> 12 [877:69]
9173 | | | `--RPAREN -> ) [877:71]
9174 | | |--COMMA -> , [877:72]
9175 | | |--EXPR -> EXPR [878:22]
9176 | | | `--PLUS -> + [878:22]
9177 | | | |--STRING_LITERAL -> "43:11: " [878:12]
9178 | | | `--METHOD_CALL -> ( [878:39]
9179 | | | |--IDENT -> getCheckMessage [878:24]
9180 | | | |--ELIST -> ELIST [878:40]
9181 | | | | |--EXPR -> EXPR [878:40]
9182 | | | | | `--IDENT -> MSG_CHILD_ERROR [878:40]
9183 | | | | |--COMMA -> , [878:55]
9184 | | | | |--EXPR -> EXPR [878:57]
9185 | | | | | `--STRING_LITERAL -> "case" [878:57]
9186 | | | | |--COMMA -> , [878:63]
9187 | | | | |--EXPR -> EXPR [878:65]
9188 | | | | | `--NUM_INT -> 10 [878:65]
9189 | | | | |--COMMA -> , [878:67]
9190 | | | | `--EXPR -> EXPR [878:69]
9191 | | | | `--NUM_INT -> 12 [878:69]
9192 | | | `--RPAREN -> ) [878:71]
9193 | | |--COMMA -> , [878:72]
9194 | | |--EXPR -> EXPR [879:22]
9195 | | | `--PLUS -> + [879:22]
9196 | | | |--STRING_LITERAL -> "44:15: " [879:12]
9197 | | | `--METHOD_CALL -> ( [879:39]
9198 | | | |--IDENT -> getCheckMessage [879:24]
9199 | | | |--ELIST -> ELIST [879:40]
9200 | | | | |--EXPR -> EXPR [879:40]
9201 | | | | | `--IDENT -> MSG_CHILD_ERROR [879:40]
9202 | | | | |--COMMA -> , [879:55]
9203 | | | | |--EXPR -> EXPR [879:57]
9204 | | | | | `--STRING_LITERAL -> "block" [879:57]
9205 | | | | |--COMMA -> , [879:64]
9206 | | | | |--EXPR -> EXPR [879:66]
9207 | | | | | `--NUM_INT -> 14 [879:66]
9208 | | | | |--COMMA -> , [879:68]
9209 | | | | `--EXPR -> EXPR [879:70]
9210 | | | | `--NUM_INT -> 16 [879:70]
9211 | | | `--RPAREN -> ) [879:72]
9212 | | |--COMMA -> , [879:73]
9213 | | |--EXPR -> EXPR [880:22]
9214 | | | `--PLUS -> + [880:22]
9215 | | | |--STRING_LITERAL -> "45:15: " [880:12]
9216 | | | `--METHOD_CALL -> ( [880:39]
9217 | | | |--IDENT -> getCheckMessage [880:24]
9218 | | | |--ELIST -> ELIST [880:40]
9219 | | | | |--EXPR -> EXPR [880:40]
9220 | | | | | `--IDENT -> MSG_CHILD_ERROR [880:40]
9221 | | | | |--COMMA -> , [880:55]
9222 | | | | |--EXPR -> EXPR [880:57]
9223 | | | | | `--STRING_LITERAL -> "block" [880:57]
9224 | | | | |--COMMA -> , [880:64]
9225 | | | | |--EXPR -> EXPR [880:66]
9226 | | | | | `--NUM_INT -> 14 [880:66]
9227 | | | | |--COMMA -> , [880:68]
9228 | | | | `--EXPR -> EXPR [880:70]
9229 | | | | `--NUM_INT -> 16 [880:70]
9230 | | | `--RPAREN -> ) [880:72]
9231 | | |--COMMA -> , [880:73]
9232 | | |--EXPR -> EXPR [881:22]
9233 | | | `--PLUS -> + [881:22]
9234 | | | |--STRING_LITERAL -> "53:15: " [881:12]
9235 | | | `--METHOD_CALL -> ( [881:39]
9236 | | | |--IDENT -> getCheckMessage [881:24]
9237 | | | |--ELIST -> ELIST [881:40]
9238 | | | | |--EXPR -> EXPR [881:40]
9239 | | | | | `--IDENT -> MSG_CHILD_ERROR [881:40]
9240 | | | | |--COMMA -> , [881:55]
9241 | | | | |--EXPR -> EXPR [881:57]
9242 | | | | | `--STRING_LITERAL -> "block" [881:57]
9243 | | | | |--COMMA -> , [881:64]
9244 | | | | |--EXPR -> EXPR [881:66]
9245 | | | | | `--NUM_INT -> 14 [881:66]
9246 | | | | |--COMMA -> , [881:68]
9247 | | | | `--EXPR -> EXPR [881:70]
9248 | | | | `--NUM_INT -> 16 [881:70]
9249 | | | `--RPAREN -> ) [881:72]
9250 | | |--COMMA -> , [881:73]
9251 | | |--EXPR -> EXPR [882:22]
9252 | | | `--PLUS -> + [882:22]
9253 | | | |--STRING_LITERAL -> "54:19: " [882:12]
9254 | | | `--METHOD_CALL -> ( [882:39]
9255 | | | |--IDENT -> getCheckMessage [882:24]
9256 | | | |--ELIST -> ELIST [882:40]
9257 | | | | |--EXPR -> EXPR [882:40]
9258 | | | | | `--IDENT -> MSG_CHILD_ERROR [882:40]
9259 | | | | |--COMMA -> , [882:55]
9260 | | | | |--EXPR -> EXPR [882:57]
9261 | | | | | `--STRING_LITERAL -> "block" [882:57]
9262 | | | | |--COMMA -> , [882:64]
9263 | | | | |--EXPR -> EXPR [882:66]
9264 | | | | | `--NUM_INT -> 18 [882:66]
9265 | | | | |--COMMA -> , [882:68]
9266 | | | | `--EXPR -> EXPR [882:70]
9267 | | | | `--NUM_INT -> 16 [882:70]
9268 | | | `--RPAREN -> ) [882:72]
9269 | | |--COMMA -> , [882:73]
9270 | | |--EXPR -> EXPR [883:22]
9271 | | | `--PLUS -> + [883:22]
9272 | | | |--STRING_LITERAL -> "55:11: " [883:12]
9273 | | | `--METHOD_CALL -> ( [883:39]
9274 | | | |--IDENT -> getCheckMessage [883:24]
9275 | | | |--ELIST -> ELIST [883:40]
9276 | | | | |--EXPR -> EXPR [883:40]
9277 | | | | | `--IDENT -> MSG_ERROR [883:40]
9278 | | | | |--COMMA -> , [883:49]
9279 | | | | |--EXPR -> EXPR [883:51]
9280 | | | | | `--STRING_LITERAL -> "block rcurly" [883:51]
9281 | | | | |--COMMA -> , [883:65]
9282 | | | | |--EXPR -> EXPR [883:67]
9283 | | | | | `--NUM_INT -> 10 [883:67]
9284 | | | | |--COMMA -> , [883:69]
9285 | | | | `--EXPR -> EXPR [883:71]
9286 | | | | `--NUM_INT -> 12 [883:71]
9287 | | | `--RPAREN -> ) [883:73]
9288 | | |--COMMA -> , [883:74]
9289 | | |--EXPR -> EXPR [884:22]
9290 | | | `--PLUS -> + [884:22]
9291 | | | |--STRING_LITERAL -> "59:11: " [884:12]
9292 | | | `--METHOD_CALL -> ( [884:39]
9293 | | | |--IDENT -> getCheckMessage [884:24]
9294 | | | |--ELIST -> ELIST [884:40]
9295 | | | | |--EXPR -> EXPR [884:40]
9296 | | | | | `--IDENT -> MSG_ERROR [884:40]
9297 | | | | |--COMMA -> , [884:49]
9298 | | | | |--EXPR -> EXPR [884:51]
9299 | | | | | `--STRING_LITERAL -> "block lcurly" [884:51]
9300 | | | | |--COMMA -> , [884:65]
9301 | | | | |--EXPR -> EXPR [884:67]
9302 | | | | | `--NUM_INT -> 10 [884:67]
9303 | | | | |--COMMA -> , [884:69]
9304 | | | | `--EXPR -> EXPR [884:71]
9305 | | | | `--NUM_INT -> 12 [884:71]
9306 | | | `--RPAREN -> ) [884:73]
9307 | | |--COMMA -> , [884:74]
9308 | | |--EXPR -> EXPR [885:22]
9309 | | | `--PLUS -> + [885:22]
9310 | | | |--STRING_LITERAL -> "62:15: " [885:12]
9311 | | | `--METHOD_CALL -> ( [885:39]
9312 | | | |--IDENT -> getCheckMessage [885:24]
9313 | | | |--ELIST -> ELIST [885:40]
9314 | | | | |--EXPR -> EXPR [885:40]
9315 | | | | | `--IDENT -> MSG_ERROR [885:40]
9316 | | | | |--COMMA -> , [885:49]
9317 | | | | |--EXPR -> EXPR [885:51]
9318 | | | | | `--STRING_LITERAL -> "block rcurly" [885:51]
9319 | | | | |--COMMA -> , [885:65]
9320 | | | | |--EXPR -> EXPR [885:67]
9321 | | | | | `--NUM_INT -> 14 [885:67]
9322 | | | | |--COMMA -> , [885:69]
9323 | | | | `--EXPR -> EXPR [885:71]
9324 | | | | `--NUM_INT -> 12 [885:71]
9325 | | | `--RPAREN -> ) [885:73]
9326 | | |--COMMA -> , [885:74]
9327 | | |--EXPR -> EXPR [886:22]
9328 | | | `--PLUS -> + [886:22]
9329 | | | |--STRING_LITERAL -> "66:15: " [886:12]
9330 | | | `--METHOD_CALL -> ( [886:39]
9331 | | | |--IDENT -> getCheckMessage [886:24]
9332 | | | |--ELIST -> ELIST [886:40]
9333 | | | | |--EXPR -> EXPR [886:40]
9334 | | | | | `--IDENT -> MSG_ERROR [886:40]
9335 | | | | |--COMMA -> , [886:49]
9336 | | | | |--EXPR -> EXPR [886:51]
9337 | | | | | `--STRING_LITERAL -> "block lcurly" [886:51]
9338 | | | | |--COMMA -> , [886:65]
9339 | | | | |--EXPR -> EXPR [886:67]
9340 | | | | | `--NUM_INT -> 14 [886:67]
9341 | | | | |--COMMA -> , [886:69]
9342 | | | | `--EXPR -> EXPR [886:71]
9343 | | | | `--NUM_INT -> 12 [886:71]
9344 | | | `--RPAREN -> ) [886:73]
9345 | | |--COMMA -> , [886:74]
9346 | | |--EXPR -> EXPR [887:22]
9347 | | | `--PLUS -> + [887:22]
9348 | | | |--STRING_LITERAL -> "69:11: " [887:12]
9349 | | | `--METHOD_CALL -> ( [887:39]
9350 | | | |--IDENT -> getCheckMessage [887:24]
9351 | | | |--ELIST -> ELIST [887:40]
9352 | | | | |--EXPR -> EXPR [887:40]
9353 | | | | | `--IDENT -> MSG_ERROR [887:40]
9354 | | | | |--COMMA -> , [887:49]
9355 | | | | |--EXPR -> EXPR [887:51]
9356 | | | | | `--STRING_LITERAL -> "block rcurly" [887:51]
9357 | | | | |--COMMA -> , [887:65]
9358 | | | | |--EXPR -> EXPR [887:67]
9359 | | | | | `--NUM_INT -> 10 [887:67]
9360 | | | | |--COMMA -> , [887:69]
9361 | | | | `--EXPR -> EXPR [887:71]
9362 | | | | `--NUM_INT -> 12 [887:71]
9363 | | | `--RPAREN -> ) [887:73]
9364 | | |--COMMA -> , [887:74]
9365 | | |--EXPR -> EXPR [888:22]
9366 | | | `--PLUS -> + [888:22]
9367 | | | |--STRING_LITERAL -> "76:15: " [888:12]
9368 | | | `--METHOD_CALL -> ( [888:39]
9369 | | | |--IDENT -> getCheckMessage [888:24]
9370 | | | |--ELIST -> ELIST [888:40]
9371 | | | | |--EXPR -> EXPR [888:40]
9372 | | | | | `--IDENT -> MSG_CHILD_ERROR [888:40]
9373 | | | | |--COMMA -> , [888:55]
9374 | | | | |--EXPR -> EXPR [888:57]
9375 | | | | | `--STRING_LITERAL -> "case" [888:57]
9376 | | | | |--COMMA -> , [888:63]
9377 | | | | |--EXPR -> EXPR [888:65]
9378 | | | | | `--NUM_INT -> 14 [888:65]
9379 | | | | |--COMMA -> , [888:67]
9380 | | | | `--EXPR -> EXPR [888:69]
9381 | | | | `--NUM_INT -> 16 [888:69]
9382 | | | `--RPAREN -> ) [888:71]
9383 | | |--COMMA -> , [888:72]
9384 | | |--EXPR -> EXPR [889:22]
9385 | | | `--PLUS -> + [889:22]
9386 | | | |--STRING_LITERAL -> "81:15: " [889:12]
9387 | | | `--METHOD_CALL -> ( [889:39]
9388 | | | |--IDENT -> getCheckMessage [889:24]
9389 | | | |--ELIST -> ELIST [889:40]
9390 | | | | |--EXPR -> EXPR [889:40]
9391 | | | | | `--IDENT -> MSG_CHILD_ERROR [889:40]
9392 | | | | |--COMMA -> , [889:55]
9393 | | | | |--EXPR -> EXPR [889:57]
9394 | | | | | `--STRING_LITERAL -> "case" [889:57]
9395 | | | | |--COMMA -> , [889:63]
9396 | | | | |--EXPR -> EXPR [889:65]
9397 | | | | | `--NUM_INT -> 14 [889:65]
9398 | | | | |--COMMA -> , [889:67]
9399 | | | | `--EXPR -> EXPR [889:69]
9400 | | | | `--NUM_INT -> 16 [889:69]
9401 | | | `--RPAREN -> ) [889:71]
9402 | | |--COMMA -> , [889:72]
9403 | | |--EXPR -> EXPR [890:21]
9404 | | | `--PLUS -> + [890:21]
9405 | | | |--STRING_LITERAL -> "89:7: " [890:12]
9406 | | | `--METHOD_CALL -> ( [890:38]
9407 | | | |--IDENT -> getCheckMessage [890:23]
9408 | | | |--ELIST -> ELIST [890:39]
9409 | | | | |--EXPR -> EXPR [890:39]
9410 | | | | | `--IDENT -> MSG_ERROR [890:39]
9411 | | | | |--COMMA -> , [890:48]
9412 | | | | |--EXPR -> EXPR [890:50]
9413 | | | | | `--STRING_LITERAL -> "switch rcurly" [890:50]
9414 | | | | |--COMMA -> , [890:65]
9415 | | | | |--EXPR -> EXPR [890:67]
9416 | | | | | `--NUM_INT -> 6 [890:67]
9417 | | | | |--COMMA -> , [890:68]
9418 | | | | `--EXPR -> EXPR [890:70]
9419 | | | | `--NUM_INT -> 8 [890:70]
9420 | | | `--RPAREN -> ) [890:71]
9421 | | |--COMMA -> , [890:72]
9422 | | |--EXPR -> EXPR [891:21]
9423 | | | `--PLUS -> + [891:21]
9424 | | | |--STRING_LITERAL -> "92:7: " [891:12]
9425 | | | `--METHOD_CALL -> ( [891:38]
9426 | | | |--IDENT -> getCheckMessage [891:23]
9427 | | | |--ELIST -> ELIST [891:39]
9428 | | | | |--EXPR -> EXPR [891:39]
9429 | | | | | `--IDENT -> MSG_ERROR [891:39]
9430 | | | | |--COMMA -> , [891:48]
9431 | | | | |--EXPR -> EXPR [891:50]
9432 | | | | | `--STRING_LITERAL -> "switch lcurly" [891:50]
9433 | | | | |--COMMA -> , [891:65]
9434 | | | | |--EXPR -> EXPR [891:67]
9435 | | | | | `--NUM_INT -> 6 [891:67]
9436 | | | | |--COMMA -> , [891:68]
9437 | | | | `--EXPR -> EXPR [891:70]
9438 | | | | `--NUM_INT -> 8 [891:70]
9439 | | | `--RPAREN -> ) [891:71]
9440 | | |--COMMA -> , [891:72]
9441 | | |--EXPR -> EXPR [892:22]
9442 | | | `--PLUS -> + [892:22]
9443 | | | |--STRING_LITERAL -> "93:11: " [892:12]
9444 | | | `--METHOD_CALL -> ( [892:39]
9445 | | | |--IDENT -> getCheckMessage [892:24]
9446 | | | |--ELIST -> ELIST [892:40]
9447 | | | | |--EXPR -> EXPR [892:40]
9448 | | | | | `--IDENT -> MSG_ERROR [892:40]
9449 | | | | |--COMMA -> , [892:49]
9450 | | | | |--EXPR -> EXPR [892:51]
9451 | | | | | `--STRING_LITERAL -> "switch rcurly" [892:51]
9452 | | | | |--COMMA -> , [892:66]
9453 | | | | |--EXPR -> EXPR [892:68]
9454 | | | | | `--NUM_INT -> 10 [892:68]
9455 | | | | |--COMMA -> , [892:70]
9456 | | | | `--EXPR -> EXPR [892:72]
9457 | | | | `--NUM_INT -> 8 [892:72]
9458 | | | `--RPAREN -> ) [892:73]
9459 | | |--COMMA -> , [892:74]
9460 | | |--EXPR -> EXPR [893:22]
9461 | | | `--PLUS -> + [893:22]
9462 | | | |--STRING_LITERAL -> "95:11: " [893:12]
9463 | | | `--METHOD_CALL -> ( [893:39]
9464 | | | |--IDENT -> getCheckMessage [893:24]
9465 | | | |--ELIST -> ELIST [893:40]
9466 | | | | |--EXPR -> EXPR [893:40]
9467 | | | | | `--IDENT -> MSG_ERROR [893:40]
9468 | | | | |--COMMA -> , [893:49]
9469 | | | | |--EXPR -> EXPR [893:51]
9470 | | | | | `--STRING_LITERAL -> "switch lcurly" [893:51]
9471 | | | | |--COMMA -> , [893:66]
9472 | | | | |--EXPR -> EXPR [893:68]
9473 | | | | | `--NUM_INT -> 10 [893:68]
9474 | | | | |--COMMA -> , [893:70]
9475 | | | | `--EXPR -> EXPR [893:72]
9476 | | | | `--NUM_INT -> 8 [893:72]
9477 | | | `--RPAREN -> ) [893:73]
9478 | | |--COMMA -> , [893:74]
9479 | | |--EXPR -> EXPR [894:21]
9480 | | | `--PLUS -> + [894:21]
9481 | | | |--STRING_LITERAL -> "96:7: " [894:12]
9482 | | | `--METHOD_CALL -> ( [894:38]
9483 | | | |--IDENT -> getCheckMessage [894:23]
9484 | | | |--ELIST -> ELIST [894:39]
9485 | | | | |--EXPR -> EXPR [894:39]
9486 | | | | | `--IDENT -> MSG_ERROR [894:39]
9487 | | | | |--COMMA -> , [894:48]
9488 | | | | |--EXPR -> EXPR [894:50]
9489 | | | | | `--STRING_LITERAL -> "switch rcurly" [894:50]
9490 | | | | |--COMMA -> , [894:65]
9491 | | | | |--EXPR -> EXPR [894:67]
9492 | | | | | `--NUM_INT -> 6 [894:67]
9493 | | | | |--COMMA -> , [894:68]
9494 | | | | `--EXPR -> EXPR [894:70]
9495 | | | | `--NUM_INT -> 8 [894:70]
9496 | | | `--RPAREN -> ) [894:71]
9497 | | |--COMMA -> , [894:72]
9498 | | |--EXPR -> EXPR [895:21]
9499 | | | `--PLUS -> + [895:21]
9500 | | | |--STRING_LITERAL -> "99:9: " [895:12]
9501 | | | `--METHOD_CALL -> ( [895:38]
9502 | | | |--IDENT -> getCheckMessage [895:23]
9503 | | | |--ELIST -> ELIST [895:39]
9504 | | | | |--EXPR -> EXPR [895:39]
9505 | | | | | `--IDENT -> MSG_CHILD_ERROR [895:39]
9506 | | | | |--COMMA -> , [895:54]
9507 | | | | |--EXPR -> EXPR [895:56]
9508 | | | | | `--STRING_LITERAL -> "case" [895:56]
9509 | | | | |--COMMA -> , [895:62]
9510 | | | | |--EXPR -> EXPR [895:64]
9511 | | | | | `--NUM_INT -> 8 [895:64]
9512 | | | | |--COMMA -> , [895:65]
9513 | | | | `--EXPR -> EXPR [895:67]
9514 | | | | `--NUM_INT -> 12 [895:67]
9515 | | | `--RPAREN -> ) [895:69]
9516 | | |--COMMA -> , [895:70]
9517 | | |--EXPR -> EXPR [896:23]
9518 | | | `--PLUS -> + [896:23]
9519 | | | |--STRING_LITERAL -> "100:13: " [896:12]
9520 | | | `--METHOD_CALL -> ( [896:40]
9521 | | | |--IDENT -> getCheckMessage [896:25]
9522 | | | |--ELIST -> ELIST [896:41]
9523 | | | | |--EXPR -> EXPR [896:41]
9524 | | | | | `--IDENT -> MSG_ERROR [896:41]
9525 | | | | |--COMMA -> , [896:50]
9526 | | | | |--EXPR -> EXPR [896:52]
9527 | | | | | `--STRING_LITERAL -> "if" [896:52]
9528 | | | | |--COMMA -> , [896:56]
9529 | | | | |--EXPR -> EXPR [896:58]
9530 | | | | | `--NUM_INT -> 12 [896:58]
9531 | | | | |--COMMA -> , [896:60]
9532 | | | | `--EXPR -> EXPR [896:62]
9533 | | | | `--NUM_INT -> 16 [896:62]
9534 | | | `--RPAREN -> ) [896:64]
9535 | | |--COMMA -> , [896:65]
9536 | | |--EXPR -> EXPR [897:23]
9537 | | | `--PLUS -> + [897:23]
9538 | | | |--STRING_LITERAL -> "101:17: " [897:12]
9539 | | | `--METHOD_CALL -> ( [897:40]
9540 | | | |--IDENT -> getCheckMessage [897:25]
9541 | | | |--ELIST -> ELIST [897:41]
9542 | | | | |--EXPR -> EXPR [897:41]
9543 | | | | | `--IDENT -> MSG_CHILD_ERROR [897:41]
9544 | | | | |--COMMA -> , [897:56]
9545 | | | | |--EXPR -> EXPR [897:58]
9546 | | | | | `--STRING_LITERAL -> "if" [897:58]
9547 | | | | |--COMMA -> , [897:62]
9548 | | | | |--EXPR -> EXPR [897:64]
9549 | | | | | `--NUM_INT -> 16 [897:64]
9550 | | | | |--COMMA -> , [897:66]
9551 | | | | `--EXPR -> EXPR [897:68]
9552 | | | | `--NUM_INT -> 20 [897:68]
9553 | | | `--RPAREN -> ) [897:70]
9554 | | |--COMMA -> , [897:71]
9555 | | |--EXPR -> EXPR [898:23]
9556 | | | `--PLUS -> + [898:23]
9557 | | | |--STRING_LITERAL -> "102:13: " [898:12]
9558 | | | `--METHOD_CALL -> ( [898:40]
9559 | | | |--IDENT -> getCheckMessage [898:25]
9560 | | | |--ELIST -> ELIST [898:41]
9561 | | | | |--EXPR -> EXPR [898:41]
9562 | | | | | `--IDENT -> MSG_ERROR [898:41]
9563 | | | | |--COMMA -> , [898:50]
9564 | | | | |--EXPR -> EXPR [898:52]
9565 | | | | | `--STRING_LITERAL -> "else" [898:52]
9566 | | | | |--COMMA -> , [898:58]
9567 | | | | |--EXPR -> EXPR [898:60]
9568 | | | | | `--NUM_INT -> 12 [898:60]
9569 | | | | |--COMMA -> , [898:62]
9570 | | | | `--EXPR -> EXPR [898:64]
9571 | | | | `--NUM_INT -> 16 [898:64]
9572 | | | `--RPAREN -> ) [898:66]
9573 | | |--COMMA -> , [898:67]
9574 | | |--EXPR -> EXPR [899:23]
9575 | | | `--PLUS -> + [899:23]
9576 | | | |--STRING_LITERAL -> "103:17: " [899:12]
9577 | | | `--METHOD_CALL -> ( [899:40]
9578 | | | |--IDENT -> getCheckMessage [899:25]
9579 | | | |--ELIST -> ELIST [899:41]
9580 | | | | |--EXPR -> EXPR [899:41]
9581 | | | | | `--IDENT -> MSG_CHILD_ERROR [899:41]
9582 | | | | |--COMMA -> , [899:56]
9583 | | | | |--EXPR -> EXPR [899:58]
9584 | | | | | `--STRING_LITERAL -> "else" [899:58]
9585 | | | | |--COMMA -> , [899:64]
9586 | | | | |--EXPR -> EXPR [899:66]
9587 | | | | | `--NUM_INT -> 16 [899:66]
9588 | | | | |--COMMA -> , [899:68]
9589 | | | | `--EXPR -> EXPR [899:70]
9590 | | | | `--NUM_INT -> 20 [899:70]
9591 | | | `--RPAREN -> ) [899:72]
9592 | | |--COMMA -> , [899:73]
9593 | | |--EXPR -> EXPR [900:23]
9594 | | | `--PLUS -> + [900:23]
9595 | | | |--STRING_LITERAL -> "106:17: " [900:12]
9596 | | | `--METHOD_CALL -> ( [900:40]
9597 | | | |--IDENT -> getCheckMessage [900:25]
9598 | | | |--ELIST -> ELIST [900:41]
9599 | | | | |--EXPR -> EXPR [900:41]
9600 | | | | | `--IDENT -> MSG_CHILD_ERROR [900:41]
9601 | | | | |--COMMA -> , [900:56]
9602 | | | | |--EXPR -> EXPR [900:58]
9603 | | | | | `--STRING_LITERAL -> "case" [900:58]
9604 | | | | |--COMMA -> , [900:64]
9605 | | | | |--EXPR -> EXPR [900:66]
9606 | | | | | `--NUM_INT -> 4 [900:66]
9607 | | | | |--COMMA -> , [900:67]
9608 | | | | `--EXPR -> EXPR [900:69]
9609 | | | | `--NUM_INT -> 12 [900:69]
9610 | | | `--RPAREN -> ) [900:71]
9611 | | |--COMMA -> , [900:72]
9612 | | `--RCURLY -> } [901:8]
9613 | |--SEMI -> ; [901:9]
9614 | |--EXPR -> EXPR [902:19]
9615 | | `--METHOD_CALL -> ( [902:19]
9616 | | |--IDENT -> verifyWarns [902:8]
9617 | | |--ELIST -> ELIST [902:20]
9618 | | | |--EXPR -> EXPR [902:20]
9619 | | | | `--IDENT -> checkConfig [902:20]
9620 | | | |--COMMA -> , [902:31]
9621 | | | |--EXPR -> EXPR [902:33]
9622 | | | | `--IDENT -> fileName [902:33]
9623 | | | |--COMMA -> , [902:41]
9624 | | | `--EXPR -> EXPR [902:43]
9625 | | | `--IDENT -> expected [902:43]
9626 | | `--RPAREN -> ) [902:51]
9627 | |--SEMI -> ; [902:52]
9628 | `--RCURLY -> } [903:4]
9629 |--METHOD_DEF -> METHOD_DEF [905:4]
9630 | |--MODIFIERS -> MODIFIERS [905:4]
9631 | | |--ANNOTATION -> ANNOTATION [905:4]
9632 | | | |--AT -> @ [905:4]
9633 | | | `--IDENT -> Test [905:5]
9634 | | `--LITERAL_PUBLIC -> public [906:4]
9635 | |--TYPE -> TYPE [906:11]
9636 | | `--LITERAL_VOID -> void [906:11]
9637 | |--IDENT -> testIfElseWithNoCurly [906:16]
9638 | |--LPAREN -> ( [906:37]
9639 | |--PARAMETERS -> PARAMETERS [906:38]
9640 | |--RPAREN -> ) [906:38]
9641 | |--LITERAL_THROWS -> throws [907:12]
9642 | | `--IDENT -> Exception [907:19]
9643 | `--SLIST -> { [907:29]
9644 | |--VARIABLE_DEF -> VARIABLE_DEF [908:8]
9645 | | |--MODIFIERS -> MODIFIERS [908:8]
9646 | | | `--FINAL -> final [908:8]
9647 | | |--TYPE -> TYPE [908:14]
9648 | | | `--IDENT -> DefaultConfiguration [908:14]
9649 | | |--IDENT -> checkConfig [908:35]
9650 | | `--ASSIGN -> = [908:47]
9651 | | `--EXPR -> EXPR [908:67]
9652 | | `--METHOD_CALL -> ( [908:67]
9653 | | |--IDENT -> createModuleConfig [908:49]
9654 | | |--ELIST -> ELIST [908:84]
9655 | | | `--EXPR -> EXPR [908:84]
9656 | | | `--DOT -> . [908:84]
9657 | | | |--IDENT -> IndentationCheck [908:68]
9658 | | | `--LITERAL_CLASS -> class [908:85]
9659 | | `--RPAREN -> ) [908:90]
9660 | |--SEMI -> ; [908:91]
9661 | |--EXPR -> EXPR [910:32]
9662 | | `--METHOD_CALL -> ( [910:32]
9663 | | |--DOT -> . [910:19]
9664 | | | |--IDENT -> checkConfig [910:8]
9665 | | | `--IDENT -> addAttribute [910:20]
9666 | | |--ELIST -> ELIST [910:33]
9667 | | | |--EXPR -> EXPR [910:33]
9668 | | | | `--STRING_LITERAL -> "arrayInitIndent" [910:33]
9669 | | | |--COMMA -> , [910:50]
9670 | | | `--EXPR -> EXPR [910:52]
9671 | | | `--STRING_LITERAL -> "4" [910:52]
9672 | | `--RPAREN -> ) [910:55]
9673 | |--SEMI -> ; [910:56]
9674 | |--EXPR -> EXPR [911:32]
9675 | | `--METHOD_CALL -> ( [911:32]
9676 | | |--DOT -> . [911:19]
9677 | | | |--IDENT -> checkConfig [911:8]
9678 | | | `--IDENT -> addAttribute [911:20]
9679 | | |--ELIST -> ELIST [911:33]
9680 | | | |--EXPR -> EXPR [911:33]
9681 | | | | `--STRING_LITERAL -> "basicOffset" [911:33]
9682 | | | |--COMMA -> , [911:46]
9683 | | | `--EXPR -> EXPR [911:48]
9684 | | | `--STRING_LITERAL -> "4" [911:48]
9685 | | `--RPAREN -> ) [911:51]
9686 | |--SEMI -> ; [911:52]
9687 | |--EXPR -> EXPR [912:32]
9688 | | `--METHOD_CALL -> ( [912:32]
9689 | | |--DOT -> . [912:19]
9690 | | | |--IDENT -> checkConfig [912:8]
9691 | | | `--IDENT -> addAttribute [912:20]
9692 | | |--ELIST -> ELIST [912:33]
9693 | | | |--EXPR -> EXPR [912:33]
9694 | | | | `--STRING_LITERAL -> "braceAdjustment" [912:33]
9695 | | | |--COMMA -> , [912:50]
9696 | | | `--EXPR -> EXPR [912:52]
9697 | | | `--STRING_LITERAL -> "0" [912:52]
9698 | | `--RPAREN -> ) [912:55]
9699 | |--SEMI -> ; [912:56]
9700 | |--EXPR -> EXPR [913:32]
9701 | | `--METHOD_CALL -> ( [913:32]
9702 | | |--DOT -> . [913:19]
9703 | | | |--IDENT -> checkConfig [913:8]
9704 | | | `--IDENT -> addAttribute [913:20]
9705 | | |--ELIST -> ELIST [913:33]
9706 | | | |--EXPR -> EXPR [913:33]
9707 | | | | `--STRING_LITERAL -> "caseIndent" [913:33]
9708 | | | |--COMMA -> , [913:45]
9709 | | | `--EXPR -> EXPR [913:47]
9710 | | | `--STRING_LITERAL -> "4" [913:47]
9711 | | `--RPAREN -> ) [913:50]
9712 | |--SEMI -> ; [913:51]
9713 | |--EXPR -> EXPR [914:32]
9714 | | `--METHOD_CALL -> ( [914:32]
9715 | | |--DOT -> . [914:19]
9716 | | | |--IDENT -> checkConfig [914:8]
9717 | | | `--IDENT -> addAttribute [914:20]
9718 | | |--ELIST -> ELIST [914:33]
9719 | | | |--EXPR -> EXPR [914:33]
9720 | | | | `--STRING_LITERAL -> "forceStrictCondition" [914:33]
9721 | | | |--COMMA -> , [914:55]
9722 | | | `--EXPR -> EXPR [914:57]
9723 | | | `--STRING_LITERAL -> "false" [914:57]
9724 | | `--RPAREN -> ) [914:64]
9725 | |--SEMI -> ; [914:65]
9726 | |--EXPR -> EXPR [915:32]
9727 | | `--METHOD_CALL -> ( [915:32]
9728 | | |--DOT -> . [915:19]
9729 | | | |--IDENT -> checkConfig [915:8]
9730 | | | `--IDENT -> addAttribute [915:20]
9731 | | |--ELIST -> ELIST [915:33]
9732 | | | |--EXPR -> EXPR [915:33]
9733 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [915:33]
9734 | | | |--COMMA -> , [915:58]
9735 | | | `--EXPR -> EXPR [915:60]
9736 | | | `--STRING_LITERAL -> "4" [915:60]
9737 | | `--RPAREN -> ) [915:63]
9738 | |--SEMI -> ; [915:64]
9739 | |--EXPR -> EXPR [916:32]
9740 | | `--METHOD_CALL -> ( [916:32]
9741 | | |--DOT -> . [916:19]
9742 | | | |--IDENT -> checkConfig [916:8]
9743 | | | `--IDENT -> addAttribute [916:20]
9744 | | |--ELIST -> ELIST [916:33]
9745 | | | |--EXPR -> EXPR [916:33]
9746 | | | | `--STRING_LITERAL -> "tabWidth" [916:33]
9747 | | | |--COMMA -> , [916:43]
9748 | | | `--EXPR -> EXPR [916:45]
9749 | | | `--STRING_LITERAL -> "4" [916:45]
9750 | | `--RPAREN -> ) [916:48]
9751 | |--SEMI -> ; [916:49]
9752 | |--EXPR -> EXPR [917:32]
9753 | | `--METHOD_CALL -> ( [917:32]
9754 | | |--DOT -> . [917:19]
9755 | | | |--IDENT -> checkConfig [917:8]
9756 | | | `--IDENT -> addAttribute [917:20]
9757 | | |--ELIST -> ELIST [917:33]
9758 | | | |--EXPR -> EXPR [917:33]
9759 | | | | `--STRING_LITERAL -> "throwsIndent" [917:33]
9760 | | | |--COMMA -> , [917:47]
9761 | | | `--EXPR -> EXPR [917:49]
9762 | | | `--STRING_LITERAL -> "4" [917:49]
9763 | | `--RPAREN -> ) [917:52]
9764 | |--SEMI -> ; [917:53]
9765 | |--VARIABLE_DEF -> VARIABLE_DEF [918:8]
9766 | | |--MODIFIERS -> MODIFIERS [918:8]
9767 | | | `--FINAL -> final [918:8]
9768 | | |--TYPE -> TYPE [918:14]
9769 | | | `--IDENT -> String [918:14]
9770 | | |--IDENT -> fileName [918:21]
9771 | | `--ASSIGN -> = [918:30]
9772 | | `--EXPR -> EXPR [918:39]
9773 | | `--METHOD_CALL -> ( [918:39]
9774 | | |--IDENT -> getPath [918:32]
9775 | | |--ELIST -> ELIST [918:40]
9776 | | | `--EXPR -> EXPR [918:40]
9777 | | | `--STRING_LITERAL -> "InputIndentationIfElseWithNoCurly.java" [918:40]
9778 | | `--RPAREN -> ) [918:80]
9779 | |--SEMI -> ; [918:81]
9780 | |--VARIABLE_DEF -> VARIABLE_DEF [919:8]
9781 | | |--MODIFIERS -> MODIFIERS [919:8]
9782 | | | `--FINAL -> final [919:8]
9783 | | |--TYPE -> TYPE [919:20]
9784 | | | `--ARRAY_DECLARATOR -> [ [919:20]
9785 | | | |--IDENT -> String [919:14]
9786 | | | `--RBRACK -> ] [919:21]
9787 | | |--IDENT -> expected [919:23]
9788 | | `--ASSIGN -> = [919:32]
9789 | | `--ARRAY_INIT -> { [919:34]
9790 | | |--EXPR -> EXPR [920:21]
9791 | | | `--PLUS -> + [920:21]
9792 | | | |--STRING_LITERAL -> "20:1: " [920:12]
9793 | | | `--METHOD_CALL -> ( [920:38]
9794 | | | |--IDENT -> getCheckMessage [920:23]
9795 | | | |--ELIST -> ELIST [920:39]
9796 | | | | |--EXPR -> EXPR [920:39]
9797 | | | | | `--IDENT -> MSG_CHILD_ERROR [920:39]
9798 | | | | |--COMMA -> , [920:54]
9799 | | | | |--EXPR -> EXPR [920:56]
9800 | | | | | `--STRING_LITERAL -> "if" [920:56]
9801 | | | | |--COMMA -> , [920:60]
9802 | | | | |--EXPR -> EXPR [920:62]
9803 | | | | | `--NUM_INT -> 0 [920:62]
9804 | | | | |--COMMA -> , [920:63]
9805 | | | | `--EXPR -> EXPR [920:65]
9806 | | | | `--NUM_INT -> 12 [920:65]
9807 | | | `--RPAREN -> ) [920:67]
9808 | | |--COMMA -> , [920:68]
9809 | | |--EXPR -> EXPR [921:21]
9810 | | | `--PLUS -> + [921:21]
9811 | | | |--STRING_LITERAL -> "25:5: " [921:12]
9812 | | | `--METHOD_CALL -> ( [921:38]
9813 | | | |--IDENT -> getCheckMessage [921:23]
9814 | | | |--ELIST -> ELIST [921:39]
9815 | | | | |--EXPR -> EXPR [921:39]
9816 | | | | | `--IDENT -> MSG_ERROR [921:39]
9817 | | | | |--COMMA -> , [921:48]
9818 | | | | |--EXPR -> EXPR [921:50]
9819 | | | | | `--STRING_LITERAL -> "if" [921:50]
9820 | | | | |--COMMA -> , [921:54]
9821 | | | | |--EXPR -> EXPR [921:56]
9822 | | | | | `--NUM_INT -> 4 [921:56]
9823 | | | | |--COMMA -> , [921:57]
9824 | | | | `--EXPR -> EXPR [921:59]
9825 | | | | `--NUM_INT -> 8 [921:59]
9826 | | | `--RPAREN -> ) [921:60]
9827 | | |--COMMA -> , [921:61]
9828 | | |--EXPR -> EXPR [922:21]
9829 | | | `--PLUS -> + [922:21]
9830 | | | |--STRING_LITERAL -> "26:9: " [922:12]
9831 | | | `--METHOD_CALL -> ( [922:38]
9832 | | | |--IDENT -> getCheckMessage [922:23]
9833 | | | |--ELIST -> ELIST [922:39]
9834 | | | | |--EXPR -> EXPR [922:39]
9835 | | | | | `--IDENT -> MSG_CHILD_ERROR [922:39]
9836 | | | | |--COMMA -> , [922:54]
9837 | | | | |--EXPR -> EXPR [922:56]
9838 | | | | | `--STRING_LITERAL -> "if" [922:56]
9839 | | | | |--COMMA -> , [922:60]
9840 | | | | |--EXPR -> EXPR [922:62]
9841 | | | | | `--NUM_INT -> 8 [922:62]
9842 | | | | |--COMMA -> , [922:63]
9843 | | | | `--EXPR -> EXPR [922:65]
9844 | | | | `--NUM_INT -> 12 [922:65]
9845 | | | `--RPAREN -> ) [922:67]
9846 | | |--COMMA -> , [922:68]
9847 | | |--EXPR -> EXPR [923:22]
9848 | | | `--PLUS -> + [923:22]
9849 | | | |--STRING_LITERAL -> "37:13: " [923:12]
9850 | | | `--METHOD_CALL -> ( [923:39]
9851 | | | |--IDENT -> getCheckMessage [923:24]
9852 | | | |--ELIST -> ELIST [923:40]
9853 | | | | |--EXPR -> EXPR [923:40]
9854 | | | | | `--IDENT -> MSG_ERROR [923:40]
9855 | | | | |--COMMA -> , [923:49]
9856 | | | | |--EXPR -> EXPR [923:51]
9857 | | | | | `--STRING_LITERAL -> "else" [923:51]
9858 | | | | |--COMMA -> , [923:57]
9859 | | | | |--EXPR -> EXPR [923:59]
9860 | | | | | `--NUM_INT -> 12 [923:59]
9861 | | | | |--COMMA -> , [923:61]
9862 | | | | `--EXPR -> EXPR [923:63]
9863 | | | | `--NUM_INT -> 8 [923:63]
9864 | | | `--RPAREN -> ) [923:64]
9865 | | |--COMMA -> , [923:65]
9866 | | |--EXPR -> EXPR [924:21]
9867 | | | `--PLUS -> + [924:21]
9868 | | | |--STRING_LITERAL -> "39:9: " [924:12]
9869 | | | `--METHOD_CALL -> ( [924:38]
9870 | | | |--IDENT -> getCheckMessage [924:23]
9871 | | | |--ELIST -> ELIST [924:39]
9872 | | | | |--EXPR -> EXPR [924:39]
9873 | | | | | `--IDENT -> MSG_ERROR [924:39]
9874 | | | | |--COMMA -> , [924:48]
9875 | | | | |--EXPR -> EXPR [924:50]
9876 | | | | | `--STRING_LITERAL -> "if" [924:50]
9877 | | | | |--COMMA -> , [924:54]
9878 | | | | |--EXPR -> EXPR [924:56]
9879 | | | | | `--NUM_INT -> 8 [924:56]
9880 | | | | |--COMMA -> , [924:57]
9881 | | | | `--EXPR -> EXPR [924:59]
9882 | | | | `--NUM_INT -> 12 [924:59]
9883 | | | `--RPAREN -> ) [924:61]
9884 | | |--COMMA -> , [924:62]
9885 | | |--EXPR -> EXPR [925:21]
9886 | | | `--PLUS -> + [925:21]
9887 | | | |--STRING_LITERAL -> "43:9: " [925:12]
9888 | | | `--METHOD_CALL -> ( [925:38]
9889 | | | |--IDENT -> getCheckMessage [925:23]
9890 | | | |--ELIST -> ELIST [925:39]
9891 | | | | |--EXPR -> EXPR [925:39]
9892 | | | | | `--IDENT -> MSG_CHILD_ERROR [925:39]
9893 | | | | |--COMMA -> , [925:54]
9894 | | | | |--EXPR -> EXPR [925:56]
9895 | | | | | `--STRING_LITERAL -> "if" [925:56]
9896 | | | | |--COMMA -> , [925:60]
9897 | | | | |--EXPR -> EXPR [925:62]
9898 | | | | | `--NUM_INT -> 8 [925:62]
9899 | | | | |--COMMA -> , [925:63]
9900 | | | | `--EXPR -> EXPR [925:65]
9901 | | | | `--NUM_INT -> 16 [925:65]
9902 | | | `--RPAREN -> ) [925:67]
9903 | | |--COMMA -> , [925:68]
9904 | | `--RCURLY -> } [926:8]
9905 | |--SEMI -> ; [926:9]
9906 | |--EXPR -> EXPR [927:19]
9907 | | `--METHOD_CALL -> ( [927:19]
9908 | | |--IDENT -> verifyWarns [927:8]
9909 | | |--ELIST -> ELIST [927:20]
9910 | | | |--EXPR -> EXPR [927:20]
9911 | | | | `--IDENT -> checkConfig [927:20]
9912 | | | |--COMMA -> , [927:31]
9913 | | | |--EXPR -> EXPR [927:33]
9914 | | | | `--IDENT -> fileName [927:33]
9915 | | | |--COMMA -> , [927:41]
9916 | | | `--EXPR -> EXPR [927:43]
9917 | | | `--IDENT -> expected [927:43]
9918 | | `--RPAREN -> ) [927:51]
9919 | |--SEMI -> ; [927:52]
9920 | `--RCURLY -> } [928:4]
9921 |--METHOD_DEF -> METHOD_DEF [930:4]
9922 | |--MODIFIERS -> MODIFIERS [930:4]
9923 | | |--ANNOTATION -> ANNOTATION [930:4]
9924 | | | |--AT -> @ [930:4]
9925 | | | `--IDENT -> Test [930:5]
9926 | | `--LITERAL_PUBLIC -> public [931:4]
9927 | |--TYPE -> TYPE [931:11]
9928 | | `--LITERAL_VOID -> void [931:11]
9929 | |--IDENT -> testWhileWithNoCurly [931:16]
9930 | |--LPAREN -> ( [931:36]
9931 | |--PARAMETERS -> PARAMETERS [931:37]
9932 | |--RPAREN -> ) [931:37]
9933 | |--LITERAL_THROWS -> throws [932:12]
9934 | | `--IDENT -> Exception [932:19]
9935 | `--SLIST -> { [932:29]
9936 | |--VARIABLE_DEF -> VARIABLE_DEF [933:8]
9937 | | |--MODIFIERS -> MODIFIERS [933:8]
9938 | | | `--FINAL -> final [933:8]
9939 | | |--TYPE -> TYPE [933:14]
9940 | | | `--IDENT -> DefaultConfiguration [933:14]
9941 | | |--IDENT -> checkConfig [933:35]
9942 | | `--ASSIGN -> = [933:47]
9943 | | `--EXPR -> EXPR [933:67]
9944 | | `--METHOD_CALL -> ( [933:67]
9945 | | |--IDENT -> createModuleConfig [933:49]
9946 | | |--ELIST -> ELIST [933:84]
9947 | | | `--EXPR -> EXPR [933:84]
9948 | | | `--DOT -> . [933:84]
9949 | | | |--IDENT -> IndentationCheck [933:68]
9950 | | | `--LITERAL_CLASS -> class [933:85]
9951 | | `--RPAREN -> ) [933:90]
9952 | |--SEMI -> ; [933:91]
9953 | |--EXPR -> EXPR [935:32]
9954 | | `--METHOD_CALL -> ( [935:32]
9955 | | |--DOT -> . [935:19]
9956 | | | |--IDENT -> checkConfig [935:8]
9957 | | | `--IDENT -> addAttribute [935:20]
9958 | | |--ELIST -> ELIST [935:33]
9959 | | | |--EXPR -> EXPR [935:33]
9960 | | | | `--STRING_LITERAL -> "arrayInitIndent" [935:33]
9961 | | | |--COMMA -> , [935:50]
9962 | | | `--EXPR -> EXPR [935:52]
9963 | | | `--STRING_LITERAL -> "4" [935:52]
9964 | | `--RPAREN -> ) [935:55]
9965 | |--SEMI -> ; [935:56]
9966 | |--EXPR -> EXPR [936:32]
9967 | | `--METHOD_CALL -> ( [936:32]
9968 | | |--DOT -> . [936:19]
9969 | | | |--IDENT -> checkConfig [936:8]
9970 | | | `--IDENT -> addAttribute [936:20]
9971 | | |--ELIST -> ELIST [936:33]
9972 | | | |--EXPR -> EXPR [936:33]
9973 | | | | `--STRING_LITERAL -> "basicOffset" [936:33]
9974 | | | |--COMMA -> , [936:46]
9975 | | | `--EXPR -> EXPR [936:48]
9976 | | | `--STRING_LITERAL -> "4" [936:48]
9977 | | `--RPAREN -> ) [936:51]
9978 | |--SEMI -> ; [936:52]
9979 | |--EXPR -> EXPR [937:32]
9980 | | `--METHOD_CALL -> ( [937:32]
9981 | | |--DOT -> . [937:19]
9982 | | | |--IDENT -> checkConfig [937:8]
9983 | | | `--IDENT -> addAttribute [937:20]
9984 | | |--ELIST -> ELIST [937:33]
9985 | | | |--EXPR -> EXPR [937:33]
9986 | | | | `--STRING_LITERAL -> "braceAdjustment" [937:33]
9987 | | | |--COMMA -> , [937:50]
9988 | | | `--EXPR -> EXPR [937:52]
9989 | | | `--STRING_LITERAL -> "0" [937:52]
9990 | | `--RPAREN -> ) [937:55]
9991 | |--SEMI -> ; [937:56]
9992 | |--EXPR -> EXPR [938:32]
9993 | | `--METHOD_CALL -> ( [938:32]
9994 | | |--DOT -> . [938:19]
9995 | | | |--IDENT -> checkConfig [938:8]
9996 | | | `--IDENT -> addAttribute [938:20]
9997 | | |--ELIST -> ELIST [938:33]
9998 | | | |--EXPR -> EXPR [938:33]
9999 | | | | `--STRING_LITERAL -> "caseIndent" [938:33]
10000 | | | |--COMMA -> , [938:45]
10001 | | | `--EXPR -> EXPR [938:47]
10002 | | | `--STRING_LITERAL -> "4" [938:47]
10003 | | `--RPAREN -> ) [938:50]
10004 | |--SEMI -> ; [938:51]
10005 | |--EXPR -> EXPR [939:32]
10006 | | `--METHOD_CALL -> ( [939:32]
10007 | | |--DOT -> . [939:19]
10008 | | | |--IDENT -> checkConfig [939:8]
10009 | | | `--IDENT -> addAttribute [939:20]
10010 | | |--ELIST -> ELIST [939:33]
10011 | | | |--EXPR -> EXPR [939:33]
10012 | | | | `--STRING_LITERAL -> "forceStrictCondition" [939:33]
10013 | | | |--COMMA -> , [939:55]
10014 | | | `--EXPR -> EXPR [939:57]
10015 | | | `--STRING_LITERAL -> "false" [939:57]
10016 | | `--RPAREN -> ) [939:64]
10017 | |--SEMI -> ; [939:65]
10018 | |--EXPR -> EXPR [940:32]
10019 | | `--METHOD_CALL -> ( [940:32]
10020 | | |--DOT -> . [940:19]
10021 | | | |--IDENT -> checkConfig [940:8]
10022 | | | `--IDENT -> addAttribute [940:20]
10023 | | |--ELIST -> ELIST [940:33]
10024 | | | |--EXPR -> EXPR [940:33]
10025 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [940:33]
10026 | | | |--COMMA -> , [940:58]
10027 | | | `--EXPR -> EXPR [940:60]
10028 | | | `--STRING_LITERAL -> "4" [940:60]
10029 | | `--RPAREN -> ) [940:63]
10030 | |--SEMI -> ; [940:64]
10031 | |--EXPR -> EXPR [941:32]
10032 | | `--METHOD_CALL -> ( [941:32]
10033 | | |--DOT -> . [941:19]
10034 | | | |--IDENT -> checkConfig [941:8]
10035 | | | `--IDENT -> addAttribute [941:20]
10036 | | |--ELIST -> ELIST [941:33]
10037 | | | |--EXPR -> EXPR [941:33]
10038 | | | | `--STRING_LITERAL -> "tabWidth" [941:33]
10039 | | | |--COMMA -> , [941:43]
10040 | | | `--EXPR -> EXPR [941:45]
10041 | | | `--STRING_LITERAL -> "4" [941:45]
10042 | | `--RPAREN -> ) [941:48]
10043 | |--SEMI -> ; [941:49]
10044 | |--EXPR -> EXPR [942:32]
10045 | | `--METHOD_CALL -> ( [942:32]
10046 | | |--DOT -> . [942:19]
10047 | | | |--IDENT -> checkConfig [942:8]
10048 | | | `--IDENT -> addAttribute [942:20]
10049 | | |--ELIST -> ELIST [942:33]
10050 | | | |--EXPR -> EXPR [942:33]
10051 | | | | `--STRING_LITERAL -> "throwsIndent" [942:33]
10052 | | | |--COMMA -> , [942:47]
10053 | | | `--EXPR -> EXPR [942:49]
10054 | | | `--STRING_LITERAL -> "4" [942:49]
10055 | | `--RPAREN -> ) [942:52]
10056 | |--SEMI -> ; [942:53]
10057 | |--VARIABLE_DEF -> VARIABLE_DEF [943:8]
10058 | | |--MODIFIERS -> MODIFIERS [943:8]
10059 | | | `--FINAL -> final [943:8]
10060 | | |--TYPE -> TYPE [943:14]
10061 | | | `--IDENT -> String [943:14]
10062 | | |--IDENT -> fileName [943:21]
10063 | | `--ASSIGN -> = [943:30]
10064 | | `--EXPR -> EXPR [943:39]
10065 | | `--METHOD_CALL -> ( [943:39]
10066 | | |--IDENT -> getPath [943:32]
10067 | | |--ELIST -> ELIST [943:40]
10068 | | | `--EXPR -> EXPR [943:40]
10069 | | | `--STRING_LITERAL -> "InputIndentationWhileNoCurly.java" [943:40]
10070 | | `--RPAREN -> ) [943:75]
10071 | |--SEMI -> ; [943:76]
10072 | |--VARIABLE_DEF -> VARIABLE_DEF [944:8]
10073 | | |--MODIFIERS -> MODIFIERS [944:8]
10074 | | | `--FINAL -> final [944:8]
10075 | | |--TYPE -> TYPE [944:20]
10076 | | | `--ARRAY_DECLARATOR -> [ [944:20]
10077 | | | |--IDENT -> String [944:14]
10078 | | | `--RBRACK -> ] [944:21]
10079 | | |--IDENT -> expected [944:23]
10080 | | `--ASSIGN -> = [944:32]
10081 | | `--ARRAY_INIT -> { [944:34]
10082 | | |--EXPR -> EXPR [945:21]
10083 | | | `--PLUS -> + [945:21]
10084 | | | |--STRING_LITERAL -> "21:1: " [945:12]
10085 | | | `--METHOD_CALL -> ( [945:38]
10086 | | | |--IDENT -> getCheckMessage [945:23]
10087 | | | |--ELIST -> ELIST [945:39]
10088 | | | | |--EXPR -> EXPR [945:39]
10089 | | | | | `--IDENT -> MSG_CHILD_ERROR [945:39]
10090 | | | | |--COMMA -> , [945:54]
10091 | | | | |--EXPR -> EXPR [945:56]
10092 | | | | | `--STRING_LITERAL -> "while" [945:56]
10093 | | | | |--COMMA -> , [945:63]
10094 | | | | |--EXPR -> EXPR [945:65]
10095 | | | | | `--NUM_INT -> 0 [945:65]
10096 | | | | |--COMMA -> , [945:66]
10097 | | | | `--EXPR -> EXPR [945:68]
10098 | | | | `--NUM_INT -> 12 [945:68]
10099 | | | `--RPAREN -> ) [945:70]
10100 | | |--COMMA -> , [945:71]
10101 | | |--EXPR -> EXPR [946:21]
10102 | | | `--PLUS -> + [946:21]
10103 | | | |--STRING_LITERAL -> "26:5: " [946:12]
10104 | | | `--METHOD_CALL -> ( [946:38]
10105 | | | |--IDENT -> getCheckMessage [946:23]
10106 | | | |--ELIST -> ELIST [946:39]
10107 | | | | |--EXPR -> EXPR [946:39]
10108 | | | | | `--IDENT -> MSG_ERROR [946:39]
10109 | | | | |--COMMA -> , [946:48]
10110 | | | | |--EXPR -> EXPR [946:50]
10111 | | | | | `--STRING_LITERAL -> "while" [946:50]
10112 | | | | |--COMMA -> , [946:57]
10113 | | | | |--EXPR -> EXPR [946:59]
10114 | | | | | `--NUM_INT -> 4 [946:59]
10115 | | | | |--COMMA -> , [946:60]
10116 | | | | `--EXPR -> EXPR [946:62]
10117 | | | | `--NUM_INT -> 8 [946:62]
10118 | | | `--RPAREN -> ) [946:63]
10119 | | |--COMMA -> , [946:64]
10120 | | |--EXPR -> EXPR [947:21]
10121 | | | `--PLUS -> + [947:21]
10122 | | | |--STRING_LITERAL -> "27:9: " [947:12]
10123 | | | `--METHOD_CALL -> ( [947:38]
10124 | | | |--IDENT -> getCheckMessage [947:23]
10125 | | | |--ELIST -> ELIST [947:39]
10126 | | | | |--EXPR -> EXPR [947:39]
10127 | | | | | `--IDENT -> MSG_CHILD_ERROR [947:39]
10128 | | | | |--COMMA -> , [947:54]
10129 | | | | |--EXPR -> EXPR [947:56]
10130 | | | | | `--STRING_LITERAL -> "while" [947:56]
10131 | | | | |--COMMA -> , [947:63]
10132 | | | | |--EXPR -> EXPR [947:65]
10133 | | | | | `--NUM_INT -> 8 [947:65]
10134 | | | | |--COMMA -> , [947:66]
10135 | | | | `--EXPR -> EXPR [947:68]
10136 | | | | `--NUM_INT -> 12 [947:68]
10137 | | | `--RPAREN -> ) [947:70]
10138 | | |--COMMA -> , [947:71]
10139 | | |--EXPR -> EXPR [948:21]
10140 | | | `--PLUS -> + [948:21]
10141 | | | |--STRING_LITERAL -> "32:9: " [948:12]
10142 | | | `--METHOD_CALL -> ( [948:38]
10143 | | | |--IDENT -> getCheckMessage [948:23]
10144 | | | |--ELIST -> ELIST [948:39]
10145 | | | | |--EXPR -> EXPR [948:39]
10146 | | | | | `--IDENT -> MSG_ERROR [948:39]
10147 | | | | |--COMMA -> , [948:48]
10148 | | | | |--EXPR -> EXPR [948:50]
10149 | | | | | `--STRING_LITERAL -> "while" [948:50]
10150 | | | | |--COMMA -> , [948:57]
10151 | | | | |--EXPR -> EXPR [948:59]
10152 | | | | | `--NUM_INT -> 8 [948:59]
10153 | | | | |--COMMA -> , [948:60]
10154 | | | | `--EXPR -> EXPR [948:62]
10155 | | | | `--NUM_INT -> 12 [948:62]
10156 | | | `--RPAREN -> ) [948:64]
10157 | | |--COMMA -> , [948:65]
10158 | | |--EXPR -> EXPR [949:21]
10159 | | | `--PLUS -> + [949:21]
10160 | | | |--STRING_LITERAL -> "36:9: " [949:12]
10161 | | | `--METHOD_CALL -> ( [949:38]
10162 | | | |--IDENT -> getCheckMessage [949:23]
10163 | | | |--ELIST -> ELIST [949:39]
10164 | | | | |--EXPR -> EXPR [949:39]
10165 | | | | | `--IDENT -> MSG_CHILD_ERROR [949:39]
10166 | | | | |--COMMA -> , [949:54]
10167 | | | | |--EXPR -> EXPR [949:56]
10168 | | | | | `--STRING_LITERAL -> "while" [949:56]
10169 | | | | |--COMMA -> , [949:63]
10170 | | | | |--EXPR -> EXPR [949:65]
10171 | | | | | `--NUM_INT -> 8 [949:65]
10172 | | | | |--COMMA -> , [949:66]
10173 | | | | `--EXPR -> EXPR [949:68]
10174 | | | | `--NUM_INT -> 16 [949:68]
10175 | | | `--RPAREN -> ) [949:70]
10176 | | |--COMMA -> , [949:71]
10177 | | `--RCURLY -> } [950:8]
10178 | |--SEMI -> ; [950:9]
10179 | |--EXPR -> EXPR [951:19]
10180 | | `--METHOD_CALL -> ( [951:19]
10181 | | |--IDENT -> verifyWarns [951:8]
10182 | | |--ELIST -> ELIST [951:20]
10183 | | | |--EXPR -> EXPR [951:20]
10184 | | | | `--IDENT -> checkConfig [951:20]
10185 | | | |--COMMA -> , [951:31]
10186 | | | |--EXPR -> EXPR [951:33]
10187 | | | | `--IDENT -> fileName [951:33]
10188 | | | |--COMMA -> , [951:41]
10189 | | | `--EXPR -> EXPR [951:43]
10190 | | | `--IDENT -> expected [951:43]
10191 | | `--RPAREN -> ) [951:51]
10192 | |--SEMI -> ; [951:52]
10193 | `--RCURLY -> } [952:4]
10194 |--METHOD_DEF -> METHOD_DEF [954:4]
10195 | |--MODIFIERS -> MODIFIERS [954:4]
10196 | | |--ANNOTATION -> ANNOTATION [954:4]
10197 | | | |--AT -> @ [954:4]
10198 | | | `--IDENT -> Test [954:5]
10199 | | `--LITERAL_PUBLIC -> public [955:4]
10200 | |--TYPE -> TYPE [955:11]
10201 | | `--LITERAL_VOID -> void [955:11]
10202 | |--IDENT -> testForWithNoCurly [955:16]
10203 | |--LPAREN -> ( [955:34]
10204 | |--PARAMETERS -> PARAMETERS [955:35]
10205 | |--RPAREN -> ) [955:35]
10206 | |--LITERAL_THROWS -> throws [956:12]
10207 | | `--IDENT -> Exception [956:19]
10208 | `--SLIST -> { [956:29]
10209 | |--VARIABLE_DEF -> VARIABLE_DEF [957:8]
10210 | | |--MODIFIERS -> MODIFIERS [957:8]
10211 | | | `--FINAL -> final [957:8]
10212 | | |--TYPE -> TYPE [957:14]
10213 | | | `--IDENT -> DefaultConfiguration [957:14]
10214 | | |--IDENT -> checkConfig [957:35]
10215 | | `--ASSIGN -> = [957:47]
10216 | | `--EXPR -> EXPR [957:67]
10217 | | `--METHOD_CALL -> ( [957:67]
10218 | | |--IDENT -> createModuleConfig [957:49]
10219 | | |--ELIST -> ELIST [957:84]
10220 | | | `--EXPR -> EXPR [957:84]
10221 | | | `--DOT -> . [957:84]
10222 | | | |--IDENT -> IndentationCheck [957:68]
10223 | | | `--LITERAL_CLASS -> class [957:85]
10224 | | `--RPAREN -> ) [957:90]
10225 | |--SEMI -> ; [957:91]
10226 | |--EXPR -> EXPR [959:32]
10227 | | `--METHOD_CALL -> ( [959:32]
10228 | | |--DOT -> . [959:19]
10229 | | | |--IDENT -> checkConfig [959:8]
10230 | | | `--IDENT -> addAttribute [959:20]
10231 | | |--ELIST -> ELIST [959:33]
10232 | | | |--EXPR -> EXPR [959:33]
10233 | | | | `--STRING_LITERAL -> "arrayInitIndent" [959:33]
10234 | | | |--COMMA -> , [959:50]
10235 | | | `--EXPR -> EXPR [959:52]
10236 | | | `--STRING_LITERAL -> "4" [959:52]
10237 | | `--RPAREN -> ) [959:55]
10238 | |--SEMI -> ; [959:56]
10239 | |--EXPR -> EXPR [960:32]
10240 | | `--METHOD_CALL -> ( [960:32]
10241 | | |--DOT -> . [960:19]
10242 | | | |--IDENT -> checkConfig [960:8]
10243 | | | `--IDENT -> addAttribute [960:20]
10244 | | |--ELIST -> ELIST [960:33]
10245 | | | |--EXPR -> EXPR [960:33]
10246 | | | | `--STRING_LITERAL -> "basicOffset" [960:33]
10247 | | | |--COMMA -> , [960:46]
10248 | | | `--EXPR -> EXPR [960:48]
10249 | | | `--STRING_LITERAL -> "4" [960:48]
10250 | | `--RPAREN -> ) [960:51]
10251 | |--SEMI -> ; [960:52]
10252 | |--EXPR -> EXPR [961:32]
10253 | | `--METHOD_CALL -> ( [961:32]
10254 | | |--DOT -> . [961:19]
10255 | | | |--IDENT -> checkConfig [961:8]
10256 | | | `--IDENT -> addAttribute [961:20]
10257 | | |--ELIST -> ELIST [961:33]
10258 | | | |--EXPR -> EXPR [961:33]
10259 | | | | `--STRING_LITERAL -> "braceAdjustment" [961:33]
10260 | | | |--COMMA -> , [961:50]
10261 | | | `--EXPR -> EXPR [961:52]
10262 | | | `--STRING_LITERAL -> "0" [961:52]
10263 | | `--RPAREN -> ) [961:55]
10264 | |--SEMI -> ; [961:56]
10265 | |--EXPR -> EXPR [962:32]
10266 | | `--METHOD_CALL -> ( [962:32]
10267 | | |--DOT -> . [962:19]
10268 | | | |--IDENT -> checkConfig [962:8]
10269 | | | `--IDENT -> addAttribute [962:20]
10270 | | |--ELIST -> ELIST [962:33]
10271 | | | |--EXPR -> EXPR [962:33]
10272 | | | | `--STRING_LITERAL -> "caseIndent" [962:33]
10273 | | | |--COMMA -> , [962:45]
10274 | | | `--EXPR -> EXPR [962:47]
10275 | | | `--STRING_LITERAL -> "4" [962:47]
10276 | | `--RPAREN -> ) [962:50]
10277 | |--SEMI -> ; [962:51]
10278 | |--EXPR -> EXPR [963:32]
10279 | | `--METHOD_CALL -> ( [963:32]
10280 | | |--DOT -> . [963:19]
10281 | | | |--IDENT -> checkConfig [963:8]
10282 | | | `--IDENT -> addAttribute [963:20]
10283 | | |--ELIST -> ELIST [963:33]
10284 | | | |--EXPR -> EXPR [963:33]
10285 | | | | `--STRING_LITERAL -> "forceStrictCondition" [963:33]
10286 | | | |--COMMA -> , [963:55]
10287 | | | `--EXPR -> EXPR [963:57]
10288 | | | `--STRING_LITERAL -> "false" [963:57]
10289 | | `--RPAREN -> ) [963:64]
10290 | |--SEMI -> ; [963:65]
10291 | |--EXPR -> EXPR [964:32]
10292 | | `--METHOD_CALL -> ( [964:32]
10293 | | |--DOT -> . [964:19]
10294 | | | |--IDENT -> checkConfig [964:8]
10295 | | | `--IDENT -> addAttribute [964:20]
10296 | | |--ELIST -> ELIST [964:33]
10297 | | | |--EXPR -> EXPR [964:33]
10298 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [964:33]
10299 | | | |--COMMA -> , [964:58]
10300 | | | `--EXPR -> EXPR [964:60]
10301 | | | `--STRING_LITERAL -> "4" [964:60]
10302 | | `--RPAREN -> ) [964:63]
10303 | |--SEMI -> ; [964:64]
10304 | |--EXPR -> EXPR [965:32]
10305 | | `--METHOD_CALL -> ( [965:32]
10306 | | |--DOT -> . [965:19]
10307 | | | |--IDENT -> checkConfig [965:8]
10308 | | | `--IDENT -> addAttribute [965:20]
10309 | | |--ELIST -> ELIST [965:33]
10310 | | | |--EXPR -> EXPR [965:33]
10311 | | | | `--STRING_LITERAL -> "tabWidth" [965:33]
10312 | | | |--COMMA -> , [965:43]
10313 | | | `--EXPR -> EXPR [965:45]
10314 | | | `--STRING_LITERAL -> "4" [965:45]
10315 | | `--RPAREN -> ) [965:48]
10316 | |--SEMI -> ; [965:49]
10317 | |--EXPR -> EXPR [966:32]
10318 | | `--METHOD_CALL -> ( [966:32]
10319 | | |--DOT -> . [966:19]
10320 | | | |--IDENT -> checkConfig [966:8]
10321 | | | `--IDENT -> addAttribute [966:20]
10322 | | |--ELIST -> ELIST [966:33]
10323 | | | |--EXPR -> EXPR [966:33]
10324 | | | | `--STRING_LITERAL -> "throwsIndent" [966:33]
10325 | | | |--COMMA -> , [966:47]
10326 | | | `--EXPR -> EXPR [966:49]
10327 | | | `--STRING_LITERAL -> "4" [966:49]
10328 | | `--RPAREN -> ) [966:52]
10329 | |--SEMI -> ; [966:53]
10330 | |--VARIABLE_DEF -> VARIABLE_DEF [967:8]
10331 | | |--MODIFIERS -> MODIFIERS [967:8]
10332 | | | `--FINAL -> final [967:8]
10333 | | |--TYPE -> TYPE [967:14]
10334 | | | `--IDENT -> String [967:14]
10335 | | |--IDENT -> fileName [967:21]
10336 | | `--ASSIGN -> = [967:30]
10337 | | `--EXPR -> EXPR [967:39]
10338 | | `--METHOD_CALL -> ( [967:39]
10339 | | |--IDENT -> getPath [967:32]
10340 | | |--ELIST -> ELIST [967:40]
10341 | | | `--EXPR -> EXPR [967:40]
10342 | | | `--STRING_LITERAL -> "InputIndentationForWithoutCurly.java" [967:40]
10343 | | `--RPAREN -> ) [967:78]
10344 | |--SEMI -> ; [967:79]
10345 | |--VARIABLE_DEF -> VARIABLE_DEF [968:8]
10346 | | |--MODIFIERS -> MODIFIERS [968:8]
10347 | | | `--FINAL -> final [968:8]
10348 | | |--TYPE -> TYPE [968:20]
10349 | | | `--ARRAY_DECLARATOR -> [ [968:20]
10350 | | | |--IDENT -> String [968:14]
10351 | | | `--RBRACK -> ] [968:21]
10352 | | |--IDENT -> expected [968:23]
10353 | | `--ASSIGN -> = [968:32]
10354 | | `--ARRAY_INIT -> { [968:34]
10355 | | |--EXPR -> EXPR [969:21]
10356 | | | `--PLUS -> + [969:21]
10357 | | | |--STRING_LITERAL -> "21:1: " [969:12]
10358 | | | `--METHOD_CALL -> ( [969:38]
10359 | | | |--IDENT -> getCheckMessage [969:23]
10360 | | | |--ELIST -> ELIST [969:39]
10361 | | | | |--EXPR -> EXPR [969:39]
10362 | | | | | `--IDENT -> MSG_CHILD_ERROR [969:39]
10363 | | | | |--COMMA -> , [969:54]
10364 | | | | |--EXPR -> EXPR [969:56]
10365 | | | | | `--STRING_LITERAL -> "for" [969:56]
10366 | | | | |--COMMA -> , [969:61]
10367 | | | | |--EXPR -> EXPR [969:63]
10368 | | | | | `--NUM_INT -> 0 [969:63]
10369 | | | | |--COMMA -> , [969:64]
10370 | | | | `--EXPR -> EXPR [969:66]
10371 | | | | `--NUM_INT -> 12 [969:66]
10372 | | | `--RPAREN -> ) [969:68]
10373 | | |--COMMA -> , [969:69]
10374 | | |--EXPR -> EXPR [970:21]
10375 | | | `--PLUS -> + [970:21]
10376 | | | |--STRING_LITERAL -> "26:5: " [970:12]
10377 | | | `--METHOD_CALL -> ( [970:38]
10378 | | | |--IDENT -> getCheckMessage [970:23]
10379 | | | |--ELIST -> ELIST [970:39]
10380 | | | | |--EXPR -> EXPR [970:39]
10381 | | | | | `--IDENT -> MSG_ERROR [970:39]
10382 | | | | |--COMMA -> , [970:48]
10383 | | | | |--EXPR -> EXPR [970:50]
10384 | | | | | `--STRING_LITERAL -> "for" [970:50]
10385 | | | | |--COMMA -> , [970:55]
10386 | | | | |--EXPR -> EXPR [970:57]
10387 | | | | | `--NUM_INT -> 4 [970:57]
10388 | | | | |--COMMA -> , [970:58]
10389 | | | | `--EXPR -> EXPR [970:60]
10390 | | | | `--NUM_INT -> 8 [970:60]
10391 | | | `--RPAREN -> ) [970:61]
10392 | | |--COMMA -> , [970:62]
10393 | | |--EXPR -> EXPR [971:21]
10394 | | | `--PLUS -> + [971:21]
10395 | | | |--STRING_LITERAL -> "27:9: " [971:12]
10396 | | | `--METHOD_CALL -> ( [971:38]
10397 | | | |--IDENT -> getCheckMessage [971:23]
10398 | | | |--ELIST -> ELIST [971:39]
10399 | | | | |--EXPR -> EXPR [971:39]
10400 | | | | | `--IDENT -> MSG_CHILD_ERROR [971:39]
10401 | | | | |--COMMA -> , [971:54]
10402 | | | | |--EXPR -> EXPR [971:56]
10403 | | | | | `--STRING_LITERAL -> "for" [971:56]
10404 | | | | |--COMMA -> , [971:61]
10405 | | | | |--EXPR -> EXPR [971:63]
10406 | | | | | `--NUM_INT -> 8 [971:63]
10407 | | | | |--COMMA -> , [971:64]
10408 | | | | `--EXPR -> EXPR [971:66]
10409 | | | | `--NUM_INT -> 12 [971:66]
10410 | | | `--RPAREN -> ) [971:68]
10411 | | |--COMMA -> , [971:69]
10412 | | |--EXPR -> EXPR [972:21]
10413 | | | `--PLUS -> + [972:21]
10414 | | | |--STRING_LITERAL -> "32:9: " [972:12]
10415 | | | `--METHOD_CALL -> ( [972:38]
10416 | | | |--IDENT -> getCheckMessage [972:23]
10417 | | | |--ELIST -> ELIST [972:39]
10418 | | | | |--EXPR -> EXPR [972:39]
10419 | | | | | `--IDENT -> MSG_ERROR [972:39]
10420 | | | | |--COMMA -> , [972:48]
10421 | | | | |--EXPR -> EXPR [972:50]
10422 | | | | | `--STRING_LITERAL -> "for" [972:50]
10423 | | | | |--COMMA -> , [972:55]
10424 | | | | |--EXPR -> EXPR [972:57]
10425 | | | | | `--NUM_INT -> 8 [972:57]
10426 | | | | |--COMMA -> , [972:58]
10427 | | | | `--EXPR -> EXPR [972:60]
10428 | | | | `--NUM_INT -> 12 [972:60]
10429 | | | `--RPAREN -> ) [972:62]
10430 | | |--COMMA -> , [972:63]
10431 | | |--EXPR -> EXPR [973:21]
10432 | | | `--PLUS -> + [973:21]
10433 | | | |--STRING_LITERAL -> "33:9: " [973:12]
10434 | | | `--METHOD_CALL -> ( [973:38]
10435 | | | |--IDENT -> getCheckMessage [973:23]
10436 | | | |--ELIST -> ELIST [973:39]
10437 | | | | |--EXPR -> EXPR [973:39]
10438 | | | | | `--IDENT -> MSG_CHILD_ERROR [973:39]
10439 | | | | |--COMMA -> , [973:54]
10440 | | | | |--EXPR -> EXPR [973:56]
10441 | | | | | `--STRING_LITERAL -> "for" [973:56]
10442 | | | | |--COMMA -> , [973:61]
10443 | | | | |--EXPR -> EXPR [973:63]
10444 | | | | | `--NUM_INT -> 8 [973:63]
10445 | | | | |--COMMA -> , [973:64]
10446 | | | | `--EXPR -> EXPR [973:66]
10447 | | | | `--NUM_INT -> 16 [973:66]
10448 | | | `--RPAREN -> ) [973:68]
10449 | | |--COMMA -> , [973:69]
10450 | | |--EXPR -> EXPR [974:21]
10451 | | | `--PLUS -> + [974:21]
10452 | | | |--STRING_LITERAL -> "37:9: " [974:12]
10453 | | | `--METHOD_CALL -> ( [974:38]
10454 | | | |--IDENT -> getCheckMessage [974:23]
10455 | | | |--ELIST -> ELIST [974:39]
10456 | | | | |--EXPR -> EXPR [974:39]
10457 | | | | | `--IDENT -> MSG_CHILD_ERROR [974:39]
10458 | | | | |--COMMA -> , [974:54]
10459 | | | | |--EXPR -> EXPR [974:56]
10460 | | | | | `--STRING_LITERAL -> "for" [974:56]
10461 | | | | |--COMMA -> , [974:61]
10462 | | | | |--EXPR -> EXPR [974:63]
10463 | | | | | `--NUM_INT -> 8 [974:63]
10464 | | | | |--COMMA -> , [974:64]
10465 | | | | `--EXPR -> EXPR [974:66]
10466 | | | | `--NUM_INT -> 16 [974:66]
10467 | | | `--RPAREN -> ) [974:68]
10468 | | |--COMMA -> , [974:69]
10469 | | `--RCURLY -> } [976:8]
10470 | |--SEMI -> ; [976:9]
10471 | |--EXPR -> EXPR [977:19]
10472 | | `--METHOD_CALL -> ( [977:19]
10473 | | |--IDENT -> verifyWarns [977:8]
10474 | | |--ELIST -> ELIST [977:20]
10475 | | | |--EXPR -> EXPR [977:20]
10476 | | | | `--IDENT -> checkConfig [977:20]
10477 | | | |--COMMA -> , [977:31]
10478 | | | |--EXPR -> EXPR [977:33]
10479 | | | | `--IDENT -> fileName [977:33]
10480 | | | |--COMMA -> , [977:41]
10481 | | | `--EXPR -> EXPR [977:43]
10482 | | | `--IDENT -> expected [977:43]
10483 | | `--RPAREN -> ) [977:51]
10484 | |--SEMI -> ; [977:52]
10485 | `--RCURLY -> } [978:4]
10486 |--METHOD_DEF -> METHOD_DEF [980:4]
10487 | |--MODIFIERS -> MODIFIERS [980:4]
10488 | | |--ANNOTATION -> ANNOTATION [980:4]
10489 | | | |--AT -> @ [980:4]
10490 | | | `--IDENT -> Test [980:5]
10491 | | `--LITERAL_PUBLIC -> public [981:4]
10492 | |--TYPE -> TYPE [981:11]
10493 | | `--LITERAL_VOID -> void [981:11]
10494 | |--IDENT -> testDoWhileWithoutCurly [981:16]
10495 | |--LPAREN -> ( [981:39]
10496 | |--PARAMETERS -> PARAMETERS [981:40]
10497 | |--RPAREN -> ) [981:40]
10498 | |--LITERAL_THROWS -> throws [982:12]
10499 | | `--IDENT -> Exception [982:19]
10500 | `--SLIST -> { [982:29]
10501 | |--VARIABLE_DEF -> VARIABLE_DEF [983:8]
10502 | | |--MODIFIERS -> MODIFIERS [983:8]
10503 | | | `--FINAL -> final [983:8]
10504 | | |--TYPE -> TYPE [983:14]
10505 | | | `--IDENT -> DefaultConfiguration [983:14]
10506 | | |--IDENT -> checkConfig [983:35]
10507 | | `--ASSIGN -> = [983:47]
10508 | | `--EXPR -> EXPR [983:67]
10509 | | `--METHOD_CALL -> ( [983:67]
10510 | | |--IDENT -> createModuleConfig [983:49]
10511 | | |--ELIST -> ELIST [983:84]
10512 | | | `--EXPR -> EXPR [983:84]
10513 | | | `--DOT -> . [983:84]
10514 | | | |--IDENT -> IndentationCheck [983:68]
10515 | | | `--LITERAL_CLASS -> class [983:85]
10516 | | `--RPAREN -> ) [983:90]
10517 | |--SEMI -> ; [983:91]
10518 | |--EXPR -> EXPR [985:32]
10519 | | `--METHOD_CALL -> ( [985:32]
10520 | | |--DOT -> . [985:19]
10521 | | | |--IDENT -> checkConfig [985:8]
10522 | | | `--IDENT -> addAttribute [985:20]
10523 | | |--ELIST -> ELIST [985:33]
10524 | | | |--EXPR -> EXPR [985:33]
10525 | | | | `--STRING_LITERAL -> "arrayInitIndent" [985:33]
10526 | | | |--COMMA -> , [985:50]
10527 | | | `--EXPR -> EXPR [985:52]
10528 | | | `--STRING_LITERAL -> "4" [985:52]
10529 | | `--RPAREN -> ) [985:55]
10530 | |--SEMI -> ; [985:56]
10531 | |--EXPR -> EXPR [986:32]
10532 | | `--METHOD_CALL -> ( [986:32]
10533 | | |--DOT -> . [986:19]
10534 | | | |--IDENT -> checkConfig [986:8]
10535 | | | `--IDENT -> addAttribute [986:20]
10536 | | |--ELIST -> ELIST [986:33]
10537 | | | |--EXPR -> EXPR [986:33]
10538 | | | | `--STRING_LITERAL -> "basicOffset" [986:33]
10539 | | | |--COMMA -> , [986:46]
10540 | | | `--EXPR -> EXPR [986:48]
10541 | | | `--STRING_LITERAL -> "4" [986:48]
10542 | | `--RPAREN -> ) [986:51]
10543 | |--SEMI -> ; [986:52]
10544 | |--EXPR -> EXPR [987:32]
10545 | | `--METHOD_CALL -> ( [987:32]
10546 | | |--DOT -> . [987:19]
10547 | | | |--IDENT -> checkConfig [987:8]
10548 | | | `--IDENT -> addAttribute [987:20]
10549 | | |--ELIST -> ELIST [987:33]
10550 | | | |--EXPR -> EXPR [987:33]
10551 | | | | `--STRING_LITERAL -> "braceAdjustment" [987:33]
10552 | | | |--COMMA -> , [987:50]
10553 | | | `--EXPR -> EXPR [987:52]
10554 | | | `--STRING_LITERAL -> "0" [987:52]
10555 | | `--RPAREN -> ) [987:55]
10556 | |--SEMI -> ; [987:56]
10557 | |--EXPR -> EXPR [988:32]
10558 | | `--METHOD_CALL -> ( [988:32]
10559 | | |--DOT -> . [988:19]
10560 | | | |--IDENT -> checkConfig [988:8]
10561 | | | `--IDENT -> addAttribute [988:20]
10562 | | |--ELIST -> ELIST [988:33]
10563 | | | |--EXPR -> EXPR [988:33]
10564 | | | | `--STRING_LITERAL -> "caseIndent" [988:33]
10565 | | | |--COMMA -> , [988:45]
10566 | | | `--EXPR -> EXPR [988:47]
10567 | | | `--STRING_LITERAL -> "4" [988:47]
10568 | | `--RPAREN -> ) [988:50]
10569 | |--SEMI -> ; [988:51]
10570 | |--EXPR -> EXPR [989:32]
10571 | | `--METHOD_CALL -> ( [989:32]
10572 | | |--DOT -> . [989:19]
10573 | | | |--IDENT -> checkConfig [989:8]
10574 | | | `--IDENT -> addAttribute [989:20]
10575 | | |--ELIST -> ELIST [989:33]
10576 | | | |--EXPR -> EXPR [989:33]
10577 | | | | `--STRING_LITERAL -> "forceStrictCondition" [989:33]
10578 | | | |--COMMA -> , [989:55]
10579 | | | `--EXPR -> EXPR [989:57]
10580 | | | `--STRING_LITERAL -> "false" [989:57]
10581 | | `--RPAREN -> ) [989:64]
10582 | |--SEMI -> ; [989:65]
10583 | |--EXPR -> EXPR [990:32]
10584 | | `--METHOD_CALL -> ( [990:32]
10585 | | |--DOT -> . [990:19]
10586 | | | |--IDENT -> checkConfig [990:8]
10587 | | | `--IDENT -> addAttribute [990:20]
10588 | | |--ELIST -> ELIST [990:33]
10589 | | | |--EXPR -> EXPR [990:33]
10590 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [990:33]
10591 | | | |--COMMA -> , [990:58]
10592 | | | `--EXPR -> EXPR [990:60]
10593 | | | `--STRING_LITERAL -> "4" [990:60]
10594 | | `--RPAREN -> ) [990:63]
10595 | |--SEMI -> ; [990:64]
10596 | |--EXPR -> EXPR [991:32]
10597 | | `--METHOD_CALL -> ( [991:32]
10598 | | |--DOT -> . [991:19]
10599 | | | |--IDENT -> checkConfig [991:8]
10600 | | | `--IDENT -> addAttribute [991:20]
10601 | | |--ELIST -> ELIST [991:33]
10602 | | | |--EXPR -> EXPR [991:33]
10603 | | | | `--STRING_LITERAL -> "tabWidth" [991:33]
10604 | | | |--COMMA -> , [991:43]
10605 | | | `--EXPR -> EXPR [991:45]
10606 | | | `--STRING_LITERAL -> "4" [991:45]
10607 | | `--RPAREN -> ) [991:48]
10608 | |--SEMI -> ; [991:49]
10609 | |--EXPR -> EXPR [992:32]
10610 | | `--METHOD_CALL -> ( [992:32]
10611 | | |--DOT -> . [992:19]
10612 | | | |--IDENT -> checkConfig [992:8]
10613 | | | `--IDENT -> addAttribute [992:20]
10614 | | |--ELIST -> ELIST [992:33]
10615 | | | |--EXPR -> EXPR [992:33]
10616 | | | | `--STRING_LITERAL -> "throwsIndent" [992:33]
10617 | | | |--COMMA -> , [992:47]
10618 | | | `--EXPR -> EXPR [992:49]
10619 | | | `--STRING_LITERAL -> "4" [992:49]
10620 | | `--RPAREN -> ) [992:52]
10621 | |--SEMI -> ; [992:53]
10622 | |--VARIABLE_DEF -> VARIABLE_DEF [993:8]
10623 | | |--MODIFIERS -> MODIFIERS [993:8]
10624 | | | `--FINAL -> final [993:8]
10625 | | |--TYPE -> TYPE [993:14]
10626 | | | `--IDENT -> String [993:14]
10627 | | |--IDENT -> fileName [993:21]
10628 | | `--ASSIGN -> = [993:30]
10629 | | `--EXPR -> EXPR [993:39]
10630 | | `--METHOD_CALL -> ( [993:39]
10631 | | |--IDENT -> getPath [993:32]
10632 | | |--ELIST -> ELIST [993:40]
10633 | | | `--EXPR -> EXPR [993:40]
10634 | | | `--STRING_LITERAL -> "InputIndentationDoWhile.java" [993:40]
10635 | | `--RPAREN -> ) [993:70]
10636 | |--SEMI -> ; [993:71]
10637 | |--VARIABLE_DEF -> VARIABLE_DEF [994:8]
10638 | | |--MODIFIERS -> MODIFIERS [994:8]
10639 | | | `--FINAL -> final [994:8]
10640 | | |--TYPE -> TYPE [994:20]
10641 | | | `--ARRAY_DECLARATOR -> [ [994:20]
10642 | | | |--IDENT -> String [994:14]
10643 | | | `--RBRACK -> ] [994:21]
10644 | | |--IDENT -> expected [994:23]
10645 | | `--ASSIGN -> = [994:32]
10646 | | `--ARRAY_INIT -> { [994:34]
10647 | | |--EXPR -> EXPR [995:21]
10648 | | | `--PLUS -> + [995:21]
10649 | | | |--STRING_LITERAL -> "23:9: " [995:12]
10650 | | | `--METHOD_CALL -> ( [995:38]
10651 | | | |--IDENT -> getCheckMessage [995:23]
10652 | | | |--ELIST -> ELIST [995:39]
10653 | | | | |--EXPR -> EXPR [995:39]
10654 | | | | | `--IDENT -> MSG_CHILD_ERROR [995:39]
10655 | | | | |--COMMA -> , [995:54]
10656 | | | | |--EXPR -> EXPR [995:56]
10657 | | | | | `--STRING_LITERAL -> "do..while" [995:56]
10658 | | | | |--COMMA -> , [995:67]
10659 | | | | |--EXPR -> EXPR [995:69]
10660 | | | | | `--NUM_INT -> 8 [995:69]
10661 | | | | |--COMMA -> , [995:70]
10662 | | | | `--EXPR -> EXPR [995:72]
10663 | | | | `--NUM_INT -> 12 [995:72]
10664 | | | `--RPAREN -> ) [995:74]
10665 | | |--COMMA -> , [995:75]
10666 | | |--EXPR -> EXPR [996:21]
10667 | | | `--PLUS -> + [996:21]
10668 | | | |--STRING_LITERAL -> "30:5: " [996:12]
10669 | | | `--METHOD_CALL -> ( [996:38]
10670 | | | |--IDENT -> getCheckMessage [996:23]
10671 | | | |--ELIST -> ELIST [996:39]
10672 | | | | |--EXPR -> EXPR [996:39]
10673 | | | | | `--IDENT -> MSG_ERROR [996:39]
10674 | | | | |--COMMA -> , [996:48]
10675 | | | | |--EXPR -> EXPR [996:50]
10676 | | | | | `--STRING_LITERAL -> "do..while while" [996:50]
10677 | | | | |--COMMA -> , [996:67]
10678 | | | | |--EXPR -> EXPR [996:69]
10679 | | | | | `--NUM_INT -> 4 [996:69]
10680 | | | | |--COMMA -> , [996:70]
10681 | | | | `--EXPR -> EXPR [996:72]
10682 | | | | `--NUM_INT -> 8 [996:72]
10683 | | | `--RPAREN -> ) [996:73]
10684 | | |--COMMA -> , [996:74]
10685 | | |--EXPR -> EXPR [997:22]
10686 | | | `--PLUS -> + [997:22]
10687 | | | |--STRING_LITERAL -> "33:13: " [997:12]
10688 | | | `--METHOD_CALL -> ( [997:39]
10689 | | | |--IDENT -> getCheckMessage [997:24]
10690 | | | |--ELIST -> ELIST [997:40]
10691 | | | | |--EXPR -> EXPR [997:40]
10692 | | | | | `--IDENT -> MSG_ERROR [997:40]
10693 | | | | |--COMMA -> , [997:49]
10694 | | | | |--EXPR -> EXPR [997:51]
10695 | | | | | `--STRING_LITERAL -> "do..while while" [997:51]
10696 | | | | |--COMMA -> , [997:68]
10697 | | | | |--EXPR -> EXPR [997:70]
10698 | | | | | `--NUM_INT -> 12 [997:70]
10699 | | | | |--COMMA -> , [997:72]
10700 | | | | `--EXPR -> EXPR [997:74]
10701 | | | | `--NUM_INT -> 8 [997:74]
10702 | | | `--RPAREN -> ) [997:75]
10703 | | |--COMMA -> , [997:76]
10704 | | `--RCURLY -> } [998:8]
10705 | |--SEMI -> ; [998:9]
10706 | |--EXPR -> EXPR [999:19]
10707 | | `--METHOD_CALL -> ( [999:19]
10708 | | |--IDENT -> verifyWarns [999:8]
10709 | | |--ELIST -> ELIST [999:20]
10710 | | | |--EXPR -> EXPR [999:20]
10711 | | | | `--IDENT -> checkConfig [999:20]
10712 | | | |--COMMA -> , [999:31]
10713 | | | |--EXPR -> EXPR [999:33]
10714 | | | | `--IDENT -> fileName [999:33]
10715 | | | |--COMMA -> , [999:41]
10716 | | | `--EXPR -> EXPR [999:43]
10717 | | | `--IDENT -> expected [999:43]
10718 | | `--RPAREN -> ) [999:51]
10719 | |--SEMI -> ; [999:52]
10720 | `--RCURLY -> } [1000:4]
10721 |--METHOD_DEF -> METHOD_DEF [1002:4]
10722 | |--MODIFIERS -> MODIFIERS [1002:4]
10723 | | |--ANNOTATION -> ANNOTATION [1002:4]
10724 | | | |--AT -> @ [1002:4]
10725 | | | `--IDENT -> Test [1002:5]
10726 | | `--LITERAL_PUBLIC -> public [1003:4]
10727 | |--TYPE -> TYPE [1003:11]
10728 | | `--LITERAL_VOID -> void [1003:11]
10729 | |--IDENT -> testValidSwitchWithChecker [1003:16]
10730 | |--LPAREN -> ( [1003:42]
10731 | |--PARAMETERS -> PARAMETERS [1003:43]
10732 | |--RPAREN -> ) [1003:43]
10733 | |--LITERAL_THROWS -> throws [1004:12]
10734 | | `--IDENT -> Exception [1004:19]
10735 | `--SLIST -> { [1004:29]
10736 | |--VARIABLE_DEF -> VARIABLE_DEF [1005:8]
10737 | | |--MODIFIERS -> MODIFIERS [1005:8]
10738 | | | `--FINAL -> final [1005:8]
10739 | | |--TYPE -> TYPE [1005:14]
10740 | | | `--IDENT -> DefaultConfiguration [1005:14]
10741 | | |--IDENT -> checkConfig [1005:35]
10742 | | `--ASSIGN -> = [1005:47]
10743 | | `--EXPR -> EXPR [1005:67]
10744 | | `--METHOD_CALL -> ( [1005:67]
10745 | | |--IDENT -> createModuleConfig [1005:49]
10746 | | |--ELIST -> ELIST [1005:84]
10747 | | | `--EXPR -> EXPR [1005:84]
10748 | | | `--DOT -> . [1005:84]
10749 | | | |--IDENT -> IndentationCheck [1005:68]
10750 | | | `--LITERAL_CLASS -> class [1005:85]
10751 | | `--RPAREN -> ) [1005:90]
10752 | |--SEMI -> ; [1005:91]
10753 | |--EXPR -> EXPR [1007:32]
10754 | | `--METHOD_CALL -> ( [1007:32]
10755 | | |--DOT -> . [1007:19]
10756 | | | |--IDENT -> checkConfig [1007:8]
10757 | | | `--IDENT -> addAttribute [1007:20]
10758 | | |--ELIST -> ELIST [1007:33]
10759 | | | |--EXPR -> EXPR [1007:33]
10760 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1007:33]
10761 | | | |--COMMA -> , [1007:50]
10762 | | | `--EXPR -> EXPR [1007:52]
10763 | | | `--STRING_LITERAL -> "4" [1007:52]
10764 | | `--RPAREN -> ) [1007:55]
10765 | |--SEMI -> ; [1007:56]
10766 | |--EXPR -> EXPR [1008:32]
10767 | | `--METHOD_CALL -> ( [1008:32]
10768 | | |--DOT -> . [1008:19]
10769 | | | |--IDENT -> checkConfig [1008:8]
10770 | | | `--IDENT -> addAttribute [1008:20]
10771 | | |--ELIST -> ELIST [1008:33]
10772 | | | |--EXPR -> EXPR [1008:33]
10773 | | | | `--STRING_LITERAL -> "basicOffset" [1008:33]
10774 | | | |--COMMA -> , [1008:46]
10775 | | | `--EXPR -> EXPR [1008:48]
10776 | | | `--STRING_LITERAL -> "4" [1008:48]
10777 | | `--RPAREN -> ) [1008:51]
10778 | |--SEMI -> ; [1008:52]
10779 | |--EXPR -> EXPR [1009:32]
10780 | | `--METHOD_CALL -> ( [1009:32]
10781 | | |--DOT -> . [1009:19]
10782 | | | |--IDENT -> checkConfig [1009:8]
10783 | | | `--IDENT -> addAttribute [1009:20]
10784 | | |--ELIST -> ELIST [1009:33]
10785 | | | |--EXPR -> EXPR [1009:33]
10786 | | | | `--STRING_LITERAL -> "braceAdjustment" [1009:33]
10787 | | | |--COMMA -> , [1009:50]
10788 | | | `--EXPR -> EXPR [1009:52]
10789 | | | `--STRING_LITERAL -> "0" [1009:52]
10790 | | `--RPAREN -> ) [1009:55]
10791 | |--SEMI -> ; [1009:56]
10792 | |--EXPR -> EXPR [1010:32]
10793 | | `--METHOD_CALL -> ( [1010:32]
10794 | | |--DOT -> . [1010:19]
10795 | | | |--IDENT -> checkConfig [1010:8]
10796 | | | `--IDENT -> addAttribute [1010:20]
10797 | | |--ELIST -> ELIST [1010:33]
10798 | | | |--EXPR -> EXPR [1010:33]
10799 | | | | `--STRING_LITERAL -> "caseIndent" [1010:33]
10800 | | | |--COMMA -> , [1010:45]
10801 | | | `--EXPR -> EXPR [1010:47]
10802 | | | `--STRING_LITERAL -> "4" [1010:47]
10803 | | `--RPAREN -> ) [1010:50]
10804 | |--SEMI -> ; [1010:51]
10805 | |--EXPR -> EXPR [1011:32]
10806 | | `--METHOD_CALL -> ( [1011:32]
10807 | | |--DOT -> . [1011:19]
10808 | | | |--IDENT -> checkConfig [1011:8]
10809 | | | `--IDENT -> addAttribute [1011:20]
10810 | | |--ELIST -> ELIST [1011:33]
10811 | | | |--EXPR -> EXPR [1011:33]
10812 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1011:33]
10813 | | | |--COMMA -> , [1011:55]
10814 | | | `--EXPR -> EXPR [1011:57]
10815 | | | `--STRING_LITERAL -> "false" [1011:57]
10816 | | `--RPAREN -> ) [1011:64]
10817 | |--SEMI -> ; [1011:65]
10818 | |--EXPR -> EXPR [1012:32]
10819 | | `--METHOD_CALL -> ( [1012:32]
10820 | | |--DOT -> . [1012:19]
10821 | | | |--IDENT -> checkConfig [1012:8]
10822 | | | `--IDENT -> addAttribute [1012:20]
10823 | | |--ELIST -> ELIST [1012:33]
10824 | | | |--EXPR -> EXPR [1012:33]
10825 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1012:33]
10826 | | | |--COMMA -> , [1012:58]
10827 | | | `--EXPR -> EXPR [1012:60]
10828 | | | `--STRING_LITERAL -> "4" [1012:60]
10829 | | `--RPAREN -> ) [1012:63]
10830 | |--SEMI -> ; [1012:64]
10831 | |--EXPR -> EXPR [1013:32]
10832 | | `--METHOD_CALL -> ( [1013:32]
10833 | | |--DOT -> . [1013:19]
10834 | | | |--IDENT -> checkConfig [1013:8]
10835 | | | `--IDENT -> addAttribute [1013:20]
10836 | | |--ELIST -> ELIST [1013:33]
10837 | | | |--EXPR -> EXPR [1013:33]
10838 | | | | `--STRING_LITERAL -> "tabWidth" [1013:33]
10839 | | | |--COMMA -> , [1013:43]
10840 | | | `--EXPR -> EXPR [1013:45]
10841 | | | `--STRING_LITERAL -> "4" [1013:45]
10842 | | `--RPAREN -> ) [1013:48]
10843 | |--SEMI -> ; [1013:49]
10844 | |--EXPR -> EXPR [1014:32]
10845 | | `--METHOD_CALL -> ( [1014:32]
10846 | | |--DOT -> . [1014:19]
10847 | | | |--IDENT -> checkConfig [1014:8]
10848 | | | `--IDENT -> addAttribute [1014:20]
10849 | | |--ELIST -> ELIST [1014:33]
10850 | | | |--EXPR -> EXPR [1014:33]
10851 | | | | `--STRING_LITERAL -> "throwsIndent" [1014:33]
10852 | | | |--COMMA -> , [1014:47]
10853 | | | `--EXPR -> EXPR [1014:49]
10854 | | | `--STRING_LITERAL -> "4" [1014:49]
10855 | | `--RPAREN -> ) [1014:52]
10856 | |--SEMI -> ; [1014:53]
10857 | |--VARIABLE_DEF -> VARIABLE_DEF [1015:8]
10858 | | |--MODIFIERS -> MODIFIERS [1015:8]
10859 | | | `--FINAL -> final [1015:8]
10860 | | |--TYPE -> TYPE [1015:14]
10861 | | | `--IDENT -> String [1015:14]
10862 | | |--IDENT -> fileName [1015:21]
10863 | | `--ASSIGN -> = [1015:30]
10864 | | `--EXPR -> EXPR [1015:39]
10865 | | `--METHOD_CALL -> ( [1015:39]
10866 | | |--IDENT -> getPath [1015:32]
10867 | | |--ELIST -> ELIST [1015:40]
10868 | | | `--EXPR -> EXPR [1015:40]
10869 | | | `--STRING_LITERAL -> "InputIndentationValidSwitchIndent.java" [1015:40]
10870 | | `--RPAREN -> ) [1015:80]
10871 | |--SEMI -> ; [1015:81]
10872 | |--VARIABLE_DEF -> VARIABLE_DEF [1016:8]
10873 | | |--MODIFIERS -> MODIFIERS [1016:8]
10874 | | | `--FINAL -> final [1016:8]
10875 | | |--TYPE -> TYPE [1016:20]
10876 | | | `--ARRAY_DECLARATOR -> [ [1016:20]
10877 | | | |--IDENT -> String [1016:14]
10878 | | | `--RBRACK -> ] [1016:21]
10879 | | |--IDENT -> expected [1016:23]
10880 | | `--ASSIGN -> = [1016:32]
10881 | | `--EXPR -> EXPR [1016:44]
10882 | | `--DOT -> . [1016:44]
10883 | | |--IDENT -> CommonUtil [1016:34]
10884 | | `--IDENT -> EMPTY_STRING_ARRAY [1016:45]
10885 | |--SEMI -> ; [1016:63]
10886 | |--EXPR -> EXPR [1017:19]
10887 | | `--METHOD_CALL -> ( [1017:19]
10888 | | |--IDENT -> verifyWarns [1017:8]
10889 | | |--ELIST -> ELIST [1017:20]
10890 | | | |--EXPR -> EXPR [1017:20]
10891 | | | | `--IDENT -> checkConfig [1017:20]
10892 | | | |--COMMA -> , [1017:31]
10893 | | | |--EXPR -> EXPR [1017:33]
10894 | | | | `--IDENT -> fileName [1017:33]
10895 | | | |--COMMA -> , [1017:41]
10896 | | | `--EXPR -> EXPR [1017:43]
10897 | | | `--IDENT -> expected [1017:43]
10898 | | `--RPAREN -> ) [1017:51]
10899 | |--SEMI -> ; [1017:52]
10900 | `--RCURLY -> } [1018:4]
10901 |--METHOD_DEF -> METHOD_DEF [1020:4]
10902 | |--MODIFIERS -> MODIFIERS [1020:4]
10903 | | |--ANNOTATION -> ANNOTATION [1020:4]
10904 | | | |--AT -> @ [1020:4]
10905 | | | `--IDENT -> Test [1020:5]
10906 | | `--LITERAL_PUBLIC -> public [1021:4]
10907 | |--TYPE -> TYPE [1021:11]
10908 | | `--LITERAL_VOID -> void [1021:11]
10909 | |--IDENT -> testNewKeyword [1021:16]
10910 | |--LPAREN -> ( [1021:30]
10911 | |--PARAMETERS -> PARAMETERS [1021:31]
10912 | |--RPAREN -> ) [1021:31]
10913 | |--LITERAL_THROWS -> throws [1021:33]
10914 | | `--IDENT -> Exception [1021:40]
10915 | `--SLIST -> { [1021:50]
10916 | |--VARIABLE_DEF -> VARIABLE_DEF [1022:8]
10917 | | |--MODIFIERS -> MODIFIERS [1022:8]
10918 | | | `--FINAL -> final [1022:8]
10919 | | |--TYPE -> TYPE [1022:14]
10920 | | | `--IDENT -> DefaultConfiguration [1022:14]
10921 | | |--IDENT -> checkConfig [1022:35]
10922 | | `--ASSIGN -> = [1022:47]
10923 | | `--EXPR -> EXPR [1022:67]
10924 | | `--METHOD_CALL -> ( [1022:67]
10925 | | |--IDENT -> createModuleConfig [1022:49]
10926 | | |--ELIST -> ELIST [1022:84]
10927 | | | `--EXPR -> EXPR [1022:84]
10928 | | | `--DOT -> . [1022:84]
10929 | | | |--IDENT -> IndentationCheck [1022:68]
10930 | | | `--LITERAL_CLASS -> class [1022:85]
10931 | | `--RPAREN -> ) [1022:90]
10932 | |--SEMI -> ; [1022:91]
10933 | |--EXPR -> EXPR [1024:32]
10934 | | `--METHOD_CALL -> ( [1024:32]
10935 | | |--DOT -> . [1024:19]
10936 | | | |--IDENT -> checkConfig [1024:8]
10937 | | | `--IDENT -> addAttribute [1024:20]
10938 | | |--ELIST -> ELIST [1024:33]
10939 | | | |--EXPR -> EXPR [1024:33]
10940 | | | | `--STRING_LITERAL -> "basicOffset" [1024:33]
10941 | | | |--COMMA -> , [1024:46]
10942 | | | `--EXPR -> EXPR [1024:48]
10943 | | | `--STRING_LITERAL -> "4" [1024:48]
10944 | | `--RPAREN -> ) [1024:51]
10945 | |--SEMI -> ; [1024:52]
10946 | |--EXPR -> EXPR [1025:32]
10947 | | `--METHOD_CALL -> ( [1025:32]
10948 | | |--DOT -> . [1025:19]
10949 | | | |--IDENT -> checkConfig [1025:8]
10950 | | | `--IDENT -> addAttribute [1025:20]
10951 | | |--ELIST -> ELIST [1025:33]
10952 | | | |--EXPR -> EXPR [1025:33]
10953 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1025:33]
10954 | | | |--COMMA -> , [1025:55]
10955 | | | `--EXPR -> EXPR [1025:57]
10956 | | | `--STRING_LITERAL -> "false" [1025:57]
10957 | | `--RPAREN -> ) [1025:64]
10958 | |--SEMI -> ; [1025:65]
10959 | |--EXPR -> EXPR [1026:32]
10960 | | `--METHOD_CALL -> ( [1026:32]
10961 | | |--DOT -> . [1026:19]
10962 | | | |--IDENT -> checkConfig [1026:8]
10963 | | | `--IDENT -> addAttribute [1026:20]
10964 | | |--ELIST -> ELIST [1026:33]
10965 | | | |--EXPR -> EXPR [1026:33]
10966 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1026:33]
10967 | | | |--COMMA -> , [1026:58]
10968 | | | `--EXPR -> EXPR [1026:60]
10969 | | | `--STRING_LITERAL -> "8" [1026:60]
10970 | | `--RPAREN -> ) [1026:63]
10971 | |--SEMI -> ; [1026:64]
10972 | |--EXPR -> EXPR [1027:32]
10973 | | `--METHOD_CALL -> ( [1027:32]
10974 | | |--DOT -> . [1027:19]
10975 | | | |--IDENT -> checkConfig [1027:8]
10976 | | | `--IDENT -> addAttribute [1027:20]
10977 | | |--ELIST -> ELIST [1027:33]
10978 | | | |--EXPR -> EXPR [1027:33]
10979 | | | | `--STRING_LITERAL -> "tabWidth" [1027:33]
10980 | | | |--COMMA -> , [1027:43]
10981 | | | `--EXPR -> EXPR [1027:45]
10982 | | | `--STRING_LITERAL -> "4" [1027:45]
10983 | | `--RPAREN -> ) [1027:48]
10984 | |--SEMI -> ; [1027:49]
10985 | |--EXPR -> EXPR [1028:32]
10986 | | `--METHOD_CALL -> ( [1028:32]
10987 | | |--DOT -> . [1028:19]
10988 | | | |--IDENT -> checkConfig [1028:8]
10989 | | | `--IDENT -> addAttribute [1028:20]
10990 | | |--ELIST -> ELIST [1028:33]
10991 | | | |--EXPR -> EXPR [1028:33]
10992 | | | | `--STRING_LITERAL -> "throwsIndent" [1028:33]
10993 | | | |--COMMA -> , [1028:47]
10994 | | | `--EXPR -> EXPR [1028:49]
10995 | | | `--STRING_LITERAL -> "8" [1028:49]
10996 | | `--RPAREN -> ) [1028:52]
10997 | |--SEMI -> ; [1028:53]
10998 | |--VARIABLE_DEF -> VARIABLE_DEF [1029:8]
10999 | | |--MODIFIERS -> MODIFIERS [1029:8]
11000 | | | `--FINAL -> final [1029:8]
11001 | | |--TYPE -> TYPE [1029:20]
11002 | | | `--ARRAY_DECLARATOR -> [ [1029:20]
11003 | | | |--IDENT -> String [1029:14]
11004 | | | `--RBRACK -> ] [1029:21]
11005 | | |--IDENT -> expected [1029:23]
11006 | | `--ASSIGN -> = [1029:32]
11007 | | `--EXPR -> EXPR [1029:44]
11008 | | `--DOT -> . [1029:44]
11009 | | |--IDENT -> CommonUtil [1029:34]
11010 | | `--IDENT -> EMPTY_STRING_ARRAY [1029:45]
11011 | |--SEMI -> ; [1029:63]
11012 | |--EXPR -> EXPR [1030:19]
11013 | | `--METHOD_CALL -> ( [1030:19]
11014 | | |--IDENT -> verifyWarns [1030:8]
11015 | | |--ELIST -> ELIST [1030:20]
11016 | | | |--EXPR -> EXPR [1030:20]
11017 | | | | `--IDENT -> checkConfig [1030:20]
11018 | | | |--COMMA -> , [1030:31]
11019 | | | |--EXPR -> EXPR [1030:40]
11020 | | | | `--METHOD_CALL -> ( [1030:40]
11021 | | | | |--IDENT -> getPath [1030:33]
11022 | | | | |--ELIST -> ELIST [1030:41]
11023 | | | | | `--EXPR -> EXPR [1030:41]
11024 | | | | | `--STRING_LITERAL -> "InputIndentationNew.java" [1030:41]
11025 | | | | `--RPAREN -> ) [1030:67]
11026 | | | |--COMMA -> , [1030:68]
11027 | | | `--EXPR -> EXPR [1030:70]
11028 | | | `--IDENT -> expected [1030:70]
11029 | | `--RPAREN -> ) [1030:78]
11030 | |--SEMI -> ; [1030:79]
11031 | `--RCURLY -> } [1031:4]
11032 |--METHOD_DEF -> METHOD_DEF [1033:4]
11033 | |--MODIFIERS -> MODIFIERS [1033:4]
11034 | | |--ANNOTATION -> ANNOTATION [1033:4]
11035 | | | |--AT -> @ [1033:4]
11036 | | | `--IDENT -> Test [1033:5]
11037 | | `--LITERAL_PUBLIC -> public [1034:4]
11038 | |--TYPE -> TYPE [1034:11]
11039 | | `--LITERAL_VOID -> void [1034:11]
11040 | |--IDENT -> testNewKeyword2 [1034:16]
11041 | |--LPAREN -> ( [1034:31]
11042 | |--PARAMETERS -> PARAMETERS [1034:32]
11043 | |--RPAREN -> ) [1034:32]
11044 | |--LITERAL_THROWS -> throws [1034:34]
11045 | | `--IDENT -> Exception [1034:41]
11046 | `--SLIST -> { [1034:51]
11047 | |--VARIABLE_DEF -> VARIABLE_DEF [1035:8]
11048 | | |--MODIFIERS -> MODIFIERS [1035:8]
11049 | | | `--FINAL -> final [1035:8]
11050 | | |--TYPE -> TYPE [1035:14]
11051 | | | `--IDENT -> DefaultConfiguration [1035:14]
11052 | | |--IDENT -> checkConfig [1035:35]
11053 | | `--ASSIGN -> = [1035:47]
11054 | | `--EXPR -> EXPR [1035:67]
11055 | | `--METHOD_CALL -> ( [1035:67]
11056 | | |--IDENT -> createModuleConfig [1035:49]
11057 | | |--ELIST -> ELIST [1035:84]
11058 | | | `--EXPR -> EXPR [1035:84]
11059 | | | `--DOT -> . [1035:84]
11060 | | | |--IDENT -> IndentationCheck [1035:68]
11061 | | | `--LITERAL_CLASS -> class [1035:85]
11062 | | `--RPAREN -> ) [1035:90]
11063 | |--SEMI -> ; [1035:91]
11064 | |--EXPR -> EXPR [1037:32]
11065 | | `--METHOD_CALL -> ( [1037:32]
11066 | | |--DOT -> . [1037:19]
11067 | | | |--IDENT -> checkConfig [1037:8]
11068 | | | `--IDENT -> addAttribute [1037:20]
11069 | | |--ELIST -> ELIST [1037:33]
11070 | | | |--EXPR -> EXPR [1037:33]
11071 | | | | `--STRING_LITERAL -> "basicOffset" [1037:33]
11072 | | | |--COMMA -> , [1037:46]
11073 | | | `--EXPR -> EXPR [1037:48]
11074 | | | `--STRING_LITERAL -> "4" [1037:48]
11075 | | `--RPAREN -> ) [1037:51]
11076 | |--SEMI -> ; [1037:52]
11077 | |--EXPR -> EXPR [1038:32]
11078 | | `--METHOD_CALL -> ( [1038:32]
11079 | | |--DOT -> . [1038:19]
11080 | | | |--IDENT -> checkConfig [1038:8]
11081 | | | `--IDENT -> addAttribute [1038:20]
11082 | | |--ELIST -> ELIST [1038:33]
11083 | | | |--EXPR -> EXPR [1038:33]
11084 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1038:33]
11085 | | | |--COMMA -> , [1038:55]
11086 | | | `--EXPR -> EXPR [1038:57]
11087 | | | `--STRING_LITERAL -> "true" [1038:57]
11088 | | `--RPAREN -> ) [1038:63]
11089 | |--SEMI -> ; [1038:64]
11090 | |--EXPR -> EXPR [1039:32]
11091 | | `--METHOD_CALL -> ( [1039:32]
11092 | | |--DOT -> . [1039:19]
11093 | | | |--IDENT -> checkConfig [1039:8]
11094 | | | `--IDENT -> addAttribute [1039:20]
11095 | | |--ELIST -> ELIST [1039:33]
11096 | | | |--EXPR -> EXPR [1039:33]
11097 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1039:33]
11098 | | | |--COMMA -> , [1039:58]
11099 | | | `--EXPR -> EXPR [1039:60]
11100 | | | `--STRING_LITERAL -> "8" [1039:60]
11101 | | `--RPAREN -> ) [1039:63]
11102 | |--SEMI -> ; [1039:64]
11103 | |--EXPR -> EXPR [1040:32]
11104 | | `--METHOD_CALL -> ( [1040:32]
11105 | | |--DOT -> . [1040:19]
11106 | | | |--IDENT -> checkConfig [1040:8]
11107 | | | `--IDENT -> addAttribute [1040:20]
11108 | | |--ELIST -> ELIST [1040:33]
11109 | | | |--EXPR -> EXPR [1040:33]
11110 | | | | `--STRING_LITERAL -> "tabWidth" [1040:33]
11111 | | | |--COMMA -> , [1040:43]
11112 | | | `--EXPR -> EXPR [1040:45]
11113 | | | `--STRING_LITERAL -> "4" [1040:45]
11114 | | `--RPAREN -> ) [1040:48]
11115 | |--SEMI -> ; [1040:49]
11116 | |--EXPR -> EXPR [1041:32]
11117 | | `--METHOD_CALL -> ( [1041:32]
11118 | | |--DOT -> . [1041:19]
11119 | | | |--IDENT -> checkConfig [1041:8]
11120 | | | `--IDENT -> addAttribute [1041:20]
11121 | | |--ELIST -> ELIST [1041:33]
11122 | | | |--EXPR -> EXPR [1041:33]
11123 | | | | `--STRING_LITERAL -> "throwsIndent" [1041:33]
11124 | | | |--COMMA -> , [1041:47]
11125 | | | `--EXPR -> EXPR [1041:49]
11126 | | | `--STRING_LITERAL -> "8" [1041:49]
11127 | | `--RPAREN -> ) [1041:52]
11128 | |--SEMI -> ; [1041:53]
11129 | |--VARIABLE_DEF -> VARIABLE_DEF [1042:8]
11130 | | |--MODIFIERS -> MODIFIERS [1042:8]
11131 | | | `--FINAL -> final [1042:8]
11132 | | |--TYPE -> TYPE [1042:20]
11133 | | | `--ARRAY_DECLARATOR -> [ [1042:20]
11134 | | | |--IDENT -> String [1042:14]
11135 | | | `--RBRACK -> ] [1042:21]
11136 | | |--IDENT -> expected [1042:23]
11137 | | `--ASSIGN -> = [1042:32]
11138 | | `--EXPR -> EXPR [1042:44]
11139 | | `--DOT -> . [1042:44]
11140 | | |--IDENT -> CommonUtil [1042:34]
11141 | | `--IDENT -> EMPTY_STRING_ARRAY [1042:45]
11142 | |--SEMI -> ; [1042:63]
11143 | |--EXPR -> EXPR [1043:19]
11144 | | `--METHOD_CALL -> ( [1043:19]
11145 | | |--IDENT -> verifyWarns [1043:8]
11146 | | |--ELIST -> ELIST [1043:20]
11147 | | | |--EXPR -> EXPR [1043:20]
11148 | | | | `--IDENT -> checkConfig [1043:20]
11149 | | | |--COMMA -> , [1043:31]
11150 | | | |--EXPR -> EXPR [1043:40]
11151 | | | | `--METHOD_CALL -> ( [1043:40]
11152 | | | | |--IDENT -> getPath [1043:33]
11153 | | | | |--ELIST -> ELIST [1043:41]
11154 | | | | | `--EXPR -> EXPR [1043:41]
11155 | | | | | `--STRING_LITERAL -> "InputIndentationNew.java" [1043:41]
11156 | | | | `--RPAREN -> ) [1043:67]
11157 | | | |--COMMA -> , [1043:68]
11158 | | | `--EXPR -> EXPR [1043:70]
11159 | | | `--IDENT -> expected [1043:70]
11160 | | `--RPAREN -> ) [1043:78]
11161 | |--SEMI -> ; [1043:79]
11162 | `--RCURLY -> } [1044:4]
11163 |--METHOD_DEF -> METHOD_DEF [1046:4]
11164 | |--MODIFIERS -> MODIFIERS [1046:4]
11165 | | |--ANNOTATION -> ANNOTATION [1046:4]
11166 | | | |--AT -> @ [1046:4]
11167 | | | `--IDENT -> Test [1046:5]
11168 | | `--LITERAL_PUBLIC -> public [1047:4]
11169 | |--TYPE -> TYPE [1047:11]
11170 | | `--LITERAL_VOID -> void [1047:11]
11171 | |--IDENT -> testValidNewKeywordWithForceStrictCondition [1047:16]
11172 | |--LPAREN -> ( [1047:59]
11173 | |--PARAMETERS -> PARAMETERS [1047:60]
11174 | |--RPAREN -> ) [1047:60]
11175 | |--LITERAL_THROWS -> throws [1047:62]
11176 | | `--IDENT -> Exception [1047:69]
11177 | `--SLIST -> { [1047:79]
11178 | |--VARIABLE_DEF -> VARIABLE_DEF [1048:8]
11179 | | |--MODIFIERS -> MODIFIERS [1048:8]
11180 | | | `--FINAL -> final [1048:8]
11181 | | |--TYPE -> TYPE [1048:14]
11182 | | | `--IDENT -> DefaultConfiguration [1048:14]
11183 | | |--IDENT -> checkConfig [1048:35]
11184 | | `--ASSIGN -> = [1048:47]
11185 | | `--EXPR -> EXPR [1048:67]
11186 | | `--METHOD_CALL -> ( [1048:67]
11187 | | |--IDENT -> createModuleConfig [1048:49]
11188 | | |--ELIST -> ELIST [1048:84]
11189 | | | `--EXPR -> EXPR [1048:84]
11190 | | | `--DOT -> . [1048:84]
11191 | | | |--IDENT -> IndentationCheck [1048:68]
11192 | | | `--LITERAL_CLASS -> class [1048:85]
11193 | | `--RPAREN -> ) [1048:90]
11194 | |--SEMI -> ; [1048:91]
11195 | |--EXPR -> EXPR [1050:32]
11196 | | `--METHOD_CALL -> ( [1050:32]
11197 | | |--DOT -> . [1050:19]
11198 | | | |--IDENT -> checkConfig [1050:8]
11199 | | | `--IDENT -> addAttribute [1050:20]
11200 | | |--ELIST -> ELIST [1050:33]
11201 | | | |--EXPR -> EXPR [1050:33]
11202 | | | | `--STRING_LITERAL -> "basicOffset" [1050:33]
11203 | | | |--COMMA -> , [1050:46]
11204 | | | `--EXPR -> EXPR [1050:48]
11205 | | | `--STRING_LITERAL -> "4" [1050:48]
11206 | | `--RPAREN -> ) [1050:51]
11207 | |--SEMI -> ; [1050:52]
11208 | |--EXPR -> EXPR [1051:32]
11209 | | `--METHOD_CALL -> ( [1051:32]
11210 | | |--DOT -> . [1051:19]
11211 | | | |--IDENT -> checkConfig [1051:8]
11212 | | | `--IDENT -> addAttribute [1051:20]
11213 | | |--ELIST -> ELIST [1051:33]
11214 | | | |--EXPR -> EXPR [1051:33]
11215 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1051:33]
11216 | | | |--COMMA -> , [1051:55]
11217 | | | `--EXPR -> EXPR [1051:57]
11218 | | | `--STRING_LITERAL -> "true" [1051:57]
11219 | | `--RPAREN -> ) [1051:63]
11220 | |--SEMI -> ; [1051:64]
11221 | |--EXPR -> EXPR [1052:32]
11222 | | `--METHOD_CALL -> ( [1052:32]
11223 | | |--DOT -> . [1052:19]
11224 | | | |--IDENT -> checkConfig [1052:8]
11225 | | | `--IDENT -> addAttribute [1052:20]
11226 | | |--ELIST -> ELIST [1052:33]
11227 | | | |--EXPR -> EXPR [1052:33]
11228 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1052:33]
11229 | | | |--COMMA -> , [1052:58]
11230 | | | `--EXPR -> EXPR [1052:60]
11231 | | | `--STRING_LITERAL -> "8" [1052:60]
11232 | | `--RPAREN -> ) [1052:63]
11233 | |--SEMI -> ; [1052:64]
11234 | |--EXPR -> EXPR [1053:32]
11235 | | `--METHOD_CALL -> ( [1053:32]
11236 | | |--DOT -> . [1053:19]
11237 | | | |--IDENT -> checkConfig [1053:8]
11238 | | | `--IDENT -> addAttribute [1053:20]
11239 | | |--ELIST -> ELIST [1053:33]
11240 | | | |--EXPR -> EXPR [1053:33]
11241 | | | | `--STRING_LITERAL -> "tabWidth" [1053:33]
11242 | | | |--COMMA -> , [1053:43]
11243 | | | `--EXPR -> EXPR [1053:45]
11244 | | | `--STRING_LITERAL -> "4" [1053:45]
11245 | | `--RPAREN -> ) [1053:48]
11246 | |--SEMI -> ; [1053:49]
11247 | |--EXPR -> EXPR [1054:32]
11248 | | `--METHOD_CALL -> ( [1054:32]
11249 | | |--DOT -> . [1054:19]
11250 | | | |--IDENT -> checkConfig [1054:8]
11251 | | | `--IDENT -> addAttribute [1054:20]
11252 | | |--ELIST -> ELIST [1054:33]
11253 | | | |--EXPR -> EXPR [1054:33]
11254 | | | | `--STRING_LITERAL -> "throwsIndent" [1054:33]
11255 | | | |--COMMA -> , [1054:47]
11256 | | | `--EXPR -> EXPR [1054:49]
11257 | | | `--STRING_LITERAL -> "8" [1054:49]
11258 | | `--RPAREN -> ) [1054:52]
11259 | |--SEMI -> ; [1054:53]
11260 | |--VARIABLE_DEF -> VARIABLE_DEF [1055:8]
11261 | | |--MODIFIERS -> MODIFIERS [1055:8]
11262 | | | `--FINAL -> final [1055:8]
11263 | | |--TYPE -> TYPE [1055:20]
11264 | | | `--ARRAY_DECLARATOR -> [ [1055:20]
11265 | | | |--IDENT -> String [1055:14]
11266 | | | `--RBRACK -> ] [1055:21]
11267 | | |--IDENT -> expected [1055:23]
11268 | | `--ASSIGN -> = [1055:32]
11269 | | `--EXPR -> EXPR [1055:44]
11270 | | `--DOT -> . [1055:44]
11271 | | |--IDENT -> CommonUtil [1055:34]
11272 | | `--IDENT -> EMPTY_STRING_ARRAY [1055:45]
11273 | |--SEMI -> ; [1055:63]
11274 | |--EXPR -> EXPR [1056:19]
11275 | | `--METHOD_CALL -> ( [1056:19]
11276 | | |--IDENT -> verifyWarns [1056:8]
11277 | | |--ELIST -> ELIST [1056:20]
11278 | | | |--EXPR -> EXPR [1056:20]
11279 | | | | `--IDENT -> checkConfig [1056:20]
11280 | | | |--COMMA -> , [1056:31]
11281 | | | |--EXPR -> EXPR [1056:40]
11282 | | | | `--METHOD_CALL -> ( [1056:40]
11283 | | | | |--IDENT -> getPath [1056:33]
11284 | | | | |--ELIST -> ELIST [1056:41]
11285 | | | | | `--EXPR -> EXPR [1056:41]
11286 | | | | | `--STRING_LITERAL -> "InputIndentationNew.java" [1056:41]
11287 | | | | `--RPAREN -> ) [1056:67]
11288 | | | |--COMMA -> , [1056:68]
11289 | | | `--EXPR -> EXPR [1056:70]
11290 | | | `--IDENT -> expected [1056:70]
11291 | | `--RPAREN -> ) [1056:78]
11292 | |--SEMI -> ; [1056:79]
11293 | `--RCURLY -> } [1057:4]
11294 |--METHOD_DEF -> METHOD_DEF [1059:4]
11295 | |--MODIFIERS -> MODIFIERS [1059:4]
11296 | | |--ANNOTATION -> ANNOTATION [1059:4]
11297 | | | |--AT -> @ [1059:4]
11298 | | | `--IDENT -> Test [1059:5]
11299 | | `--LITERAL_PUBLIC -> public [1060:4]
11300 | |--TYPE -> TYPE [1060:11]
11301 | | `--LITERAL_VOID -> void [1060:11]
11302 | |--IDENT -> testInvalidNewKeywordWithForceStrictCondition [1060:16]
11303 | |--LPAREN -> ( [1060:61]
11304 | |--PARAMETERS -> PARAMETERS [1060:62]
11305 | |--RPAREN -> ) [1060:62]
11306 | |--LITERAL_THROWS -> throws [1060:64]
11307 | | `--IDENT -> Exception [1060:71]
11308 | `--SLIST -> { [1060:81]
11309 | |--VARIABLE_DEF -> VARIABLE_DEF [1061:8]
11310 | | |--MODIFIERS -> MODIFIERS [1061:8]
11311 | | | `--FINAL -> final [1061:8]
11312 | | |--TYPE -> TYPE [1061:14]
11313 | | | `--IDENT -> DefaultConfiguration [1061:14]
11314 | | |--IDENT -> checkConfig [1061:35]
11315 | | `--ASSIGN -> = [1061:47]
11316 | | `--EXPR -> EXPR [1061:67]
11317 | | `--METHOD_CALL -> ( [1061:67]
11318 | | |--IDENT -> createModuleConfig [1061:49]
11319 | | |--ELIST -> ELIST [1061:84]
11320 | | | `--EXPR -> EXPR [1061:84]
11321 | | | `--DOT -> . [1061:84]
11322 | | | |--IDENT -> IndentationCheck [1061:68]
11323 | | | `--LITERAL_CLASS -> class [1061:85]
11324 | | `--RPAREN -> ) [1061:90]
11325 | |--SEMI -> ; [1061:91]
11326 | |--EXPR -> EXPR [1063:32]
11327 | | `--METHOD_CALL -> ( [1063:32]
11328 | | |--DOT -> . [1063:19]
11329 | | | |--IDENT -> checkConfig [1063:8]
11330 | | | `--IDENT -> addAttribute [1063:20]
11331 | | |--ELIST -> ELIST [1063:33]
11332 | | | |--EXPR -> EXPR [1063:33]
11333 | | | | `--STRING_LITERAL -> "basicOffset" [1063:33]
11334 | | | |--COMMA -> , [1063:46]
11335 | | | `--EXPR -> EXPR [1063:48]
11336 | | | `--STRING_LITERAL -> "4" [1063:48]
11337 | | `--RPAREN -> ) [1063:51]
11338 | |--SEMI -> ; [1063:52]
11339 | |--EXPR -> EXPR [1064:32]
11340 | | `--METHOD_CALL -> ( [1064:32]
11341 | | |--DOT -> . [1064:19]
11342 | | | |--IDENT -> checkConfig [1064:8]
11343 | | | `--IDENT -> addAttribute [1064:20]
11344 | | |--ELIST -> ELIST [1064:33]
11345 | | | |--EXPR -> EXPR [1064:33]
11346 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1064:33]
11347 | | | |--COMMA -> , [1064:55]
11348 | | | `--EXPR -> EXPR [1064:57]
11349 | | | `--STRING_LITERAL -> "true" [1064:57]
11350 | | `--RPAREN -> ) [1064:63]
11351 | |--SEMI -> ; [1064:64]
11352 | |--EXPR -> EXPR [1065:32]
11353 | | `--METHOD_CALL -> ( [1065:32]
11354 | | |--DOT -> . [1065:19]
11355 | | | |--IDENT -> checkConfig [1065:8]
11356 | | | `--IDENT -> addAttribute [1065:20]
11357 | | |--ELIST -> ELIST [1065:33]
11358 | | | |--EXPR -> EXPR [1065:33]
11359 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1065:33]
11360 | | | |--COMMA -> , [1065:58]
11361 | | | `--EXPR -> EXPR [1065:60]
11362 | | | `--STRING_LITERAL -> "8" [1065:60]
11363 | | `--RPAREN -> ) [1065:63]
11364 | |--SEMI -> ; [1065:64]
11365 | |--EXPR -> EXPR [1066:32]
11366 | | `--METHOD_CALL -> ( [1066:32]
11367 | | |--DOT -> . [1066:19]
11368 | | | |--IDENT -> checkConfig [1066:8]
11369 | | | `--IDENT -> addAttribute [1066:20]
11370 | | |--ELIST -> ELIST [1066:33]
11371 | | | |--EXPR -> EXPR [1066:33]
11372 | | | | `--STRING_LITERAL -> "tabWidth" [1066:33]
11373 | | | |--COMMA -> , [1066:43]
11374 | | | `--EXPR -> EXPR [1066:45]
11375 | | | `--STRING_LITERAL -> "4" [1066:45]
11376 | | `--RPAREN -> ) [1066:48]
11377 | |--SEMI -> ; [1066:49]
11378 | |--EXPR -> EXPR [1067:32]
11379 | | `--METHOD_CALL -> ( [1067:32]
11380 | | |--DOT -> . [1067:19]
11381 | | | |--IDENT -> checkConfig [1067:8]
11382 | | | `--IDENT -> addAttribute [1067:20]
11383 | | |--ELIST -> ELIST [1067:33]
11384 | | | |--EXPR -> EXPR [1067:33]
11385 | | | | `--STRING_LITERAL -> "throwsIndent" [1067:33]
11386 | | | |--COMMA -> , [1067:47]
11387 | | | `--EXPR -> EXPR [1067:49]
11388 | | | `--STRING_LITERAL -> "8" [1067:49]
11389 | | `--RPAREN -> ) [1067:52]
11390 | |--SEMI -> ; [1067:53]
11391 | |--VARIABLE_DEF -> VARIABLE_DEF [1068:8]
11392 | | |--MODIFIERS -> MODIFIERS [1068:8]
11393 | | | `--FINAL -> final [1068:8]
11394 | | |--TYPE -> TYPE [1068:20]
11395 | | | `--ARRAY_DECLARATOR -> [ [1068:20]
11396 | | | |--IDENT -> String [1068:14]
11397 | | | `--RBRACK -> ] [1068:21]
11398 | | |--IDENT -> expected [1068:23]
11399 | | `--ASSIGN -> = [1068:32]
11400 | | `--ARRAY_INIT -> { [1068:34]
11401 | | |--EXPR -> EXPR [1069:22]
11402 | | | `--PLUS -> + [1069:22]
11403 | | | |--STRING_LITERAL -> "23:17: " [1069:12]
11404 | | | `--METHOD_CALL -> ( [1069:39]
11405 | | | |--IDENT -> getCheckMessage [1069:24]
11406 | | | |--ELIST -> ELIST [1069:40]
11407 | | | | |--EXPR -> EXPR [1069:40]
11408 | | | | | `--IDENT -> MSG_ERROR [1069:40]
11409 | | | | |--COMMA -> , [1069:49]
11410 | | | | |--EXPR -> EXPR [1069:51]
11411 | | | | | `--STRING_LITERAL -> "new" [1069:51]
11412 | | | | |--COMMA -> , [1069:56]
11413 | | | | |--EXPR -> EXPR [1069:58]
11414 | | | | | `--NUM_INT -> 16 [1069:58]
11415 | | | | |--COMMA -> , [1069:60]
11416 | | | | `--EXPR -> EXPR [1069:62]
11417 | | | | `--NUM_INT -> 24 [1069:62]
11418 | | | `--RPAREN -> ) [1069:64]
11419 | | |--COMMA -> , [1069:65]
11420 | | |--EXPR -> EXPR [1070:22]
11421 | | | `--PLUS -> + [1070:22]
11422 | | | |--STRING_LITERAL -> "24:21: " [1070:12]
11423 | | | `--METHOD_CALL -> ( [1070:39]
11424 | | | |--IDENT -> getCheckMessage [1070:24]
11425 | | | |--ELIST -> ELIST [1070:40]
11426 | | | | |--EXPR -> EXPR [1070:40]
11427 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [1070:40]
11428 | | | | |--COMMA -> , [1070:61]
11429 | | | | |--EXPR -> EXPR [1070:63]
11430 | | | | | `--STRING_LITERAL -> "object def" [1070:63]
11431 | | | | |--COMMA -> , [1070:75]
11432 | | | | |--EXPR -> EXPR [1070:77]
11433 | | | | | `--NUM_INT -> 20 [1070:77]
11434 | | | | |--COMMA -> , [1070:79]
11435 | | | | `--EXPR -> EXPR [1070:81]
11436 | | | | `--STRING_LITERAL -> "28, 32, 36" [1070:81]
11437 | | | `--RPAREN -> ) [1070:93]
11438 | | |--COMMA -> , [1070:94]
11439 | | |--EXPR -> EXPR [1071:22]
11440 | | | `--PLUS -> + [1071:22]
11441 | | | |--STRING_LITERAL -> "25:17: " [1071:12]
11442 | | | `--METHOD_CALL -> ( [1071:39]
11443 | | | |--IDENT -> getCheckMessage [1071:24]
11444 | | | |--ELIST -> ELIST [1071:40]
11445 | | | | |--EXPR -> EXPR [1071:40]
11446 | | | | | `--IDENT -> MSG_ERROR_MULTI [1071:40]
11447 | | | | |--COMMA -> , [1071:55]
11448 | | | | |--EXPR -> EXPR [1071:57]
11449 | | | | | `--STRING_LITERAL -> "object def rcurly" [1071:57]
11450 | | | | |--COMMA -> , [1071:76]
11451 | | | | |--EXPR -> EXPR [1071:78]
11452 | | | | | `--NUM_INT -> 16 [1071:78]
11453 | | | | |--COMMA -> , [1071:80]
11454 | | | | `--EXPR -> EXPR [1071:82]
11455 | | | | `--STRING_LITERAL -> "24, 28, 32" [1071:82]
11456 | | | `--RPAREN -> ) [1071:94]
11457 | | |--COMMA -> , [1071:95]
11458 | | `--RCURLY -> } [1072:8]
11459 | |--SEMI -> ; [1072:9]
11460 | |--EXPR -> EXPR [1073:19]
11461 | | `--METHOD_CALL -> ( [1073:19]
11462 | | |--IDENT -> verifyWarns [1073:8]
11463 | | |--ELIST -> ELIST [1073:20]
11464 | | | |--EXPR -> EXPR [1073:20]
11465 | | | | `--IDENT -> checkConfig [1073:20]
11466 | | | |--COMMA -> , [1073:31]
11467 | | | |--EXPR -> EXPR [1074:19]
11468 | | | | `--METHOD_CALL -> ( [1074:19]
11469 | | | | |--IDENT -> getPath [1074:12]
11470 | | | | |--ELIST -> ELIST [1074:20]
11471 | | | | | `--EXPR -> EXPR [1074:20]
11472 | | | | | `--STRING_LITERAL -> "InputIndentationNewWithForceStrictCondition.java" [1074:20]
11473 | | | | `--RPAREN -> ) [1074:70]
11474 | | | |--COMMA -> , [1074:71]
11475 | | | `--EXPR -> EXPR [1074:73]
11476 | | | `--IDENT -> expected [1074:73]
11477 | | `--RPAREN -> ) [1074:81]
11478 | |--SEMI -> ; [1074:82]
11479 | `--RCURLY -> } [1075:4]
11480 |--METHOD_DEF -> METHOD_DEF [1077:4]
11481 | |--MODIFIERS -> MODIFIERS [1077:4]
11482 | | |--ANNOTATION -> ANNOTATION [1077:4]
11483 | | | |--AT -> @ [1077:4]
11484 | | | `--IDENT -> Test [1077:5]
11485 | | `--LITERAL_PUBLIC -> public [1078:4]
11486 | |--TYPE -> TYPE [1078:11]
11487 | | `--LITERAL_VOID -> void [1078:11]
11488 | |--IDENT -> testValidArrayInitDefaultIndentWithChecker [1078:16]
11489 | |--LPAREN -> ( [1078:58]
11490 | |--PARAMETERS -> PARAMETERS [1078:59]
11491 | |--RPAREN -> ) [1078:59]
11492 | |--LITERAL_THROWS -> throws [1079:12]
11493 | | `--IDENT -> Exception [1079:19]
11494 | `--SLIST -> { [1079:29]
11495 | |--VARIABLE_DEF -> VARIABLE_DEF [1080:8]
11496 | | |--MODIFIERS -> MODIFIERS [1080:8]
11497 | | | `--FINAL -> final [1080:8]
11498 | | |--TYPE -> TYPE [1080:14]
11499 | | | `--IDENT -> DefaultConfiguration [1080:14]
11500 | | |--IDENT -> checkConfig [1080:35]
11501 | | `--ASSIGN -> = [1080:47]
11502 | | `--EXPR -> EXPR [1080:67]
11503 | | `--METHOD_CALL -> ( [1080:67]
11504 | | |--IDENT -> createModuleConfig [1080:49]
11505 | | |--ELIST -> ELIST [1080:84]
11506 | | | `--EXPR -> EXPR [1080:84]
11507 | | | `--DOT -> . [1080:84]
11508 | | | |--IDENT -> IndentationCheck [1080:68]
11509 | | | `--LITERAL_CLASS -> class [1080:85]
11510 | | `--RPAREN -> ) [1080:90]
11511 | |--SEMI -> ; [1080:91]
11512 | |--EXPR -> EXPR [1082:32]
11513 | | `--METHOD_CALL -> ( [1082:32]
11514 | | |--DOT -> . [1082:19]
11515 | | | |--IDENT -> checkConfig [1082:8]
11516 | | | `--IDENT -> addAttribute [1082:20]
11517 | | |--ELIST -> ELIST [1082:33]
11518 | | | |--EXPR -> EXPR [1082:33]
11519 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1082:33]
11520 | | | |--COMMA -> , [1082:50]
11521 | | | `--EXPR -> EXPR [1082:52]
11522 | | | `--STRING_LITERAL -> "4" [1082:52]
11523 | | `--RPAREN -> ) [1082:55]
11524 | |--SEMI -> ; [1082:56]
11525 | |--EXPR -> EXPR [1083:32]
11526 | | `--METHOD_CALL -> ( [1083:32]
11527 | | |--DOT -> . [1083:19]
11528 | | | |--IDENT -> checkConfig [1083:8]
11529 | | | `--IDENT -> addAttribute [1083:20]
11530 | | |--ELIST -> ELIST [1083:33]
11531 | | | |--EXPR -> EXPR [1083:33]
11532 | | | | `--STRING_LITERAL -> "basicOffset" [1083:33]
11533 | | | |--COMMA -> , [1083:46]
11534 | | | `--EXPR -> EXPR [1083:48]
11535 | | | `--STRING_LITERAL -> "4" [1083:48]
11536 | | `--RPAREN -> ) [1083:51]
11537 | |--SEMI -> ; [1083:52]
11538 | |--EXPR -> EXPR [1084:32]
11539 | | `--METHOD_CALL -> ( [1084:32]
11540 | | |--DOT -> . [1084:19]
11541 | | | |--IDENT -> checkConfig [1084:8]
11542 | | | `--IDENT -> addAttribute [1084:20]
11543 | | |--ELIST -> ELIST [1084:33]
11544 | | | |--EXPR -> EXPR [1084:33]
11545 | | | | `--STRING_LITERAL -> "braceAdjustment" [1084:33]
11546 | | | |--COMMA -> , [1084:50]
11547 | | | `--EXPR -> EXPR [1084:52]
11548 | | | `--STRING_LITERAL -> "0" [1084:52]
11549 | | `--RPAREN -> ) [1084:55]
11550 | |--SEMI -> ; [1084:56]
11551 | |--EXPR -> EXPR [1085:32]
11552 | | `--METHOD_CALL -> ( [1085:32]
11553 | | |--DOT -> . [1085:19]
11554 | | | |--IDENT -> checkConfig [1085:8]
11555 | | | `--IDENT -> addAttribute [1085:20]
11556 | | |--ELIST -> ELIST [1085:33]
11557 | | | |--EXPR -> EXPR [1085:33]
11558 | | | | `--STRING_LITERAL -> "caseIndent" [1085:33]
11559 | | | |--COMMA -> , [1085:45]
11560 | | | `--EXPR -> EXPR [1085:47]
11561 | | | `--STRING_LITERAL -> "4" [1085:47]
11562 | | `--RPAREN -> ) [1085:50]
11563 | |--SEMI -> ; [1085:51]
11564 | |--EXPR -> EXPR [1086:32]
11565 | | `--METHOD_CALL -> ( [1086:32]
11566 | | |--DOT -> . [1086:19]
11567 | | | |--IDENT -> checkConfig [1086:8]
11568 | | | `--IDENT -> addAttribute [1086:20]
11569 | | |--ELIST -> ELIST [1086:33]
11570 | | | |--EXPR -> EXPR [1086:33]
11571 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1086:33]
11572 | | | |--COMMA -> , [1086:55]
11573 | | | `--EXPR -> EXPR [1086:57]
11574 | | | `--STRING_LITERAL -> "false" [1086:57]
11575 | | `--RPAREN -> ) [1086:64]
11576 | |--SEMI -> ; [1086:65]
11577 | |--EXPR -> EXPR [1087:32]
11578 | | `--METHOD_CALL -> ( [1087:32]
11579 | | |--DOT -> . [1087:19]
11580 | | | |--IDENT -> checkConfig [1087:8]
11581 | | | `--IDENT -> addAttribute [1087:20]
11582 | | |--ELIST -> ELIST [1087:33]
11583 | | | |--EXPR -> EXPR [1087:33]
11584 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1087:33]
11585 | | | |--COMMA -> , [1087:58]
11586 | | | `--EXPR -> EXPR [1087:60]
11587 | | | `--STRING_LITERAL -> "4" [1087:60]
11588 | | `--RPAREN -> ) [1087:63]
11589 | |--SEMI -> ; [1087:64]
11590 | |--EXPR -> EXPR [1088:32]
11591 | | `--METHOD_CALL -> ( [1088:32]
11592 | | |--DOT -> . [1088:19]
11593 | | | |--IDENT -> checkConfig [1088:8]
11594 | | | `--IDENT -> addAttribute [1088:20]
11595 | | |--ELIST -> ELIST [1088:33]
11596 | | | |--EXPR -> EXPR [1088:33]
11597 | | | | `--STRING_LITERAL -> "tabWidth" [1088:33]
11598 | | | |--COMMA -> , [1088:43]
11599 | | | `--EXPR -> EXPR [1088:45]
11600 | | | `--STRING_LITERAL -> "4" [1088:45]
11601 | | `--RPAREN -> ) [1088:48]
11602 | |--SEMI -> ; [1088:49]
11603 | |--EXPR -> EXPR [1089:32]
11604 | | `--METHOD_CALL -> ( [1089:32]
11605 | | |--DOT -> . [1089:19]
11606 | | | |--IDENT -> checkConfig [1089:8]
11607 | | | `--IDENT -> addAttribute [1089:20]
11608 | | |--ELIST -> ELIST [1089:33]
11609 | | | |--EXPR -> EXPR [1089:33]
11610 | | | | `--STRING_LITERAL -> "throwsIndent" [1089:33]
11611 | | | |--COMMA -> , [1089:47]
11612 | | | `--EXPR -> EXPR [1089:49]
11613 | | | `--STRING_LITERAL -> "4" [1089:49]
11614 | | `--RPAREN -> ) [1089:52]
11615 | |--SEMI -> ; [1089:53]
11616 | |--VARIABLE_DEF -> VARIABLE_DEF [1090:8]
11617 | | |--MODIFIERS -> MODIFIERS [1090:8]
11618 | | | `--FINAL -> final [1090:8]
11619 | | |--TYPE -> TYPE [1090:14]
11620 | | | `--IDENT -> String [1090:14]
11621 | | |--IDENT -> fileName [1090:21]
11622 | | `--ASSIGN -> = [1090:30]
11623 | | `--EXPR -> EXPR [1090:39]
11624 | | `--METHOD_CALL -> ( [1090:39]
11625 | | |--IDENT -> getPath [1090:32]
11626 | | |--ELIST -> ELIST [1090:40]
11627 | | | `--EXPR -> EXPR [1090:40]
11628 | | | `--STRING_LITERAL -> "InputIndentationValidArrayInitDefaultIndent.java" [1090:40]
11629 | | `--RPAREN -> ) [1090:90]
11630 | |--SEMI -> ; [1090:91]
11631 | |--VARIABLE_DEF -> VARIABLE_DEF [1091:8]
11632 | | |--MODIFIERS -> MODIFIERS [1091:8]
11633 | | | `--FINAL -> final [1091:8]
11634 | | |--TYPE -> TYPE [1091:20]
11635 | | | `--ARRAY_DECLARATOR -> [ [1091:20]
11636 | | | |--IDENT -> String [1091:14]
11637 | | | `--RBRACK -> ] [1091:21]
11638 | | |--IDENT -> expected [1091:23]
11639 | | `--ASSIGN -> = [1091:32]
11640 | | `--EXPR -> EXPR [1091:44]
11641 | | `--DOT -> . [1091:44]
11642 | | |--IDENT -> CommonUtil [1091:34]
11643 | | `--IDENT -> EMPTY_STRING_ARRAY [1091:45]
11644 | |--SEMI -> ; [1091:63]
11645 | |--EXPR -> EXPR [1092:19]
11646 | | `--METHOD_CALL -> ( [1092:19]
11647 | | |--IDENT -> verifyWarns [1092:8]
11648 | | |--ELIST -> ELIST [1092:20]
11649 | | | |--EXPR -> EXPR [1092:20]
11650 | | | | `--IDENT -> checkConfig [1092:20]
11651 | | | |--COMMA -> , [1092:31]
11652 | | | |--EXPR -> EXPR [1092:33]
11653 | | | | `--IDENT -> fileName [1092:33]
11654 | | | |--COMMA -> , [1092:41]
11655 | | | `--EXPR -> EXPR [1092:43]
11656 | | | `--IDENT -> expected [1092:43]
11657 | | `--RPAREN -> ) [1092:51]
11658 | |--SEMI -> ; [1092:52]
11659 | `--RCURLY -> } [1093:4]
11660 |--METHOD_DEF -> METHOD_DEF [1095:4]
11661 | |--MODIFIERS -> MODIFIERS [1095:4]
11662 | | |--ANNOTATION -> ANNOTATION [1095:4]
11663 | | | |--AT -> @ [1095:4]
11664 | | | `--IDENT -> Test [1095:5]
11665 | | `--LITERAL_PUBLIC -> public [1096:4]
11666 | |--TYPE -> TYPE [1096:11]
11667 | | `--LITERAL_VOID -> void [1096:11]
11668 | |--IDENT -> testValidArrayInitWithChecker [1096:16]
11669 | |--LPAREN -> ( [1096:45]
11670 | |--PARAMETERS -> PARAMETERS [1096:46]
11671 | |--RPAREN -> ) [1096:46]
11672 | |--LITERAL_THROWS -> throws [1097:12]
11673 | | `--IDENT -> Exception [1097:19]
11674 | `--SLIST -> { [1097:29]
11675 | |--VARIABLE_DEF -> VARIABLE_DEF [1098:8]
11676 | | |--MODIFIERS -> MODIFIERS [1098:8]
11677 | | | `--FINAL -> final [1098:8]
11678 | | |--TYPE -> TYPE [1098:14]
11679 | | | `--IDENT -> DefaultConfiguration [1098:14]
11680 | | |--IDENT -> checkConfig [1098:35]
11681 | | `--ASSIGN -> = [1098:47]
11682 | | `--EXPR -> EXPR [1098:67]
11683 | | `--METHOD_CALL -> ( [1098:67]
11684 | | |--IDENT -> createModuleConfig [1098:49]
11685 | | |--ELIST -> ELIST [1098:84]
11686 | | | `--EXPR -> EXPR [1098:84]
11687 | | | `--DOT -> . [1098:84]
11688 | | | |--IDENT -> IndentationCheck [1098:68]
11689 | | | `--LITERAL_CLASS -> class [1098:85]
11690 | | `--RPAREN -> ) [1098:90]
11691 | |--SEMI -> ; [1098:91]
11692 | |--EXPR -> EXPR [1100:32]
11693 | | `--METHOD_CALL -> ( [1100:32]
11694 | | |--DOT -> . [1100:19]
11695 | | | |--IDENT -> checkConfig [1100:8]
11696 | | | `--IDENT -> addAttribute [1100:20]
11697 | | |--ELIST -> ELIST [1100:33]
11698 | | | |--EXPR -> EXPR [1100:33]
11699 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1100:33]
11700 | | | |--COMMA -> , [1100:50]
11701 | | | `--EXPR -> EXPR [1100:52]
11702 | | | `--STRING_LITERAL -> "8" [1100:52]
11703 | | `--RPAREN -> ) [1100:55]
11704 | |--SEMI -> ; [1100:56]
11705 | |--EXPR -> EXPR [1101:32]
11706 | | `--METHOD_CALL -> ( [1101:32]
11707 | | |--DOT -> . [1101:19]
11708 | | | |--IDENT -> checkConfig [1101:8]
11709 | | | `--IDENT -> addAttribute [1101:20]
11710 | | |--ELIST -> ELIST [1101:33]
11711 | | | |--EXPR -> EXPR [1101:33]
11712 | | | | `--STRING_LITERAL -> "basicOffset" [1101:33]
11713 | | | |--COMMA -> , [1101:46]
11714 | | | `--EXPR -> EXPR [1101:48]
11715 | | | `--STRING_LITERAL -> "4" [1101:48]
11716 | | `--RPAREN -> ) [1101:51]
11717 | |--SEMI -> ; [1101:52]
11718 | |--EXPR -> EXPR [1102:32]
11719 | | `--METHOD_CALL -> ( [1102:32]
11720 | | |--DOT -> . [1102:19]
11721 | | | |--IDENT -> checkConfig [1102:8]
11722 | | | `--IDENT -> addAttribute [1102:20]
11723 | | |--ELIST -> ELIST [1102:33]
11724 | | | |--EXPR -> EXPR [1102:33]
11725 | | | | `--STRING_LITERAL -> "braceAdjustment" [1102:33]
11726 | | | |--COMMA -> , [1102:50]
11727 | | | `--EXPR -> EXPR [1102:52]
11728 | | | `--STRING_LITERAL -> "0" [1102:52]
11729 | | `--RPAREN -> ) [1102:55]
11730 | |--SEMI -> ; [1102:56]
11731 | |--EXPR -> EXPR [1103:32]
11732 | | `--METHOD_CALL -> ( [1103:32]
11733 | | |--DOT -> . [1103:19]
11734 | | | |--IDENT -> checkConfig [1103:8]
11735 | | | `--IDENT -> addAttribute [1103:20]
11736 | | |--ELIST -> ELIST [1103:33]
11737 | | | |--EXPR -> EXPR [1103:33]
11738 | | | | `--STRING_LITERAL -> "caseIndent" [1103:33]
11739 | | | |--COMMA -> , [1103:45]
11740 | | | `--EXPR -> EXPR [1103:47]
11741 | | | `--STRING_LITERAL -> "4" [1103:47]
11742 | | `--RPAREN -> ) [1103:50]
11743 | |--SEMI -> ; [1103:51]
11744 | |--EXPR -> EXPR [1104:32]
11745 | | `--METHOD_CALL -> ( [1104:32]
11746 | | |--DOT -> . [1104:19]
11747 | | | |--IDENT -> checkConfig [1104:8]
11748 | | | `--IDENT -> addAttribute [1104:20]
11749 | | |--ELIST -> ELIST [1104:33]
11750 | | | |--EXPR -> EXPR [1104:33]
11751 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1104:33]
11752 | | | |--COMMA -> , [1104:55]
11753 | | | `--EXPR -> EXPR [1104:57]
11754 | | | `--STRING_LITERAL -> "false" [1104:57]
11755 | | `--RPAREN -> ) [1104:64]
11756 | |--SEMI -> ; [1104:65]
11757 | |--EXPR -> EXPR [1105:32]
11758 | | `--METHOD_CALL -> ( [1105:32]
11759 | | |--DOT -> . [1105:19]
11760 | | | |--IDENT -> checkConfig [1105:8]
11761 | | | `--IDENT -> addAttribute [1105:20]
11762 | | |--ELIST -> ELIST [1105:33]
11763 | | | |--EXPR -> EXPR [1105:33]
11764 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1105:33]
11765 | | | |--COMMA -> , [1105:58]
11766 | | | `--EXPR -> EXPR [1105:60]
11767 | | | `--STRING_LITERAL -> "4" [1105:60]
11768 | | `--RPAREN -> ) [1105:63]
11769 | |--SEMI -> ; [1105:64]
11770 | |--EXPR -> EXPR [1106:32]
11771 | | `--METHOD_CALL -> ( [1106:32]
11772 | | |--DOT -> . [1106:19]
11773 | | | |--IDENT -> checkConfig [1106:8]
11774 | | | `--IDENT -> addAttribute [1106:20]
11775 | | |--ELIST -> ELIST [1106:33]
11776 | | | |--EXPR -> EXPR [1106:33]
11777 | | | | `--STRING_LITERAL -> "tabWidth" [1106:33]
11778 | | | |--COMMA -> , [1106:43]
11779 | | | `--EXPR -> EXPR [1106:45]
11780 | | | `--STRING_LITERAL -> "4" [1106:45]
11781 | | `--RPAREN -> ) [1106:48]
11782 | |--SEMI -> ; [1106:49]
11783 | |--EXPR -> EXPR [1107:32]
11784 | | `--METHOD_CALL -> ( [1107:32]
11785 | | |--DOT -> . [1107:19]
11786 | | | |--IDENT -> checkConfig [1107:8]
11787 | | | `--IDENT -> addAttribute [1107:20]
11788 | | |--ELIST -> ELIST [1107:33]
11789 | | | |--EXPR -> EXPR [1107:33]
11790 | | | | `--STRING_LITERAL -> "throwsIndent" [1107:33]
11791 | | | |--COMMA -> , [1107:47]
11792 | | | `--EXPR -> EXPR [1107:49]
11793 | | | `--STRING_LITERAL -> "4" [1107:49]
11794 | | `--RPAREN -> ) [1107:52]
11795 | |--SEMI -> ; [1107:53]
11796 | |--VARIABLE_DEF -> VARIABLE_DEF [1108:8]
11797 | | |--MODIFIERS -> MODIFIERS [1108:8]
11798 | | | `--FINAL -> final [1108:8]
11799 | | |--TYPE -> TYPE [1108:14]
11800 | | | `--IDENT -> String [1108:14]
11801 | | |--IDENT -> fileName [1108:21]
11802 | | `--ASSIGN -> = [1108:30]
11803 | | `--EXPR -> EXPR [1108:39]
11804 | | `--METHOD_CALL -> ( [1108:39]
11805 | | |--IDENT -> getPath [1108:32]
11806 | | |--ELIST -> ELIST [1108:40]
11807 | | | `--EXPR -> EXPR [1108:40]
11808 | | | `--STRING_LITERAL -> "InputIndentationValidArrayInitIndent.java" [1108:40]
11809 | | `--RPAREN -> ) [1108:83]
11810 | |--SEMI -> ; [1108:84]
11811 | |--VARIABLE_DEF -> VARIABLE_DEF [1109:8]
11812 | | |--MODIFIERS -> MODIFIERS [1109:8]
11813 | | | `--FINAL -> final [1109:8]
11814 | | |--TYPE -> TYPE [1109:20]
11815 | | | `--ARRAY_DECLARATOR -> [ [1109:20]
11816 | | | |--IDENT -> String [1109:14]
11817 | | | `--RBRACK -> ] [1109:21]
11818 | | |--IDENT -> expected [1109:23]
11819 | | `--ASSIGN -> = [1109:32]
11820 | | `--EXPR -> EXPR [1109:44]
11821 | | `--DOT -> . [1109:44]
11822 | | |--IDENT -> CommonUtil [1109:34]
11823 | | `--IDENT -> EMPTY_STRING_ARRAY [1109:45]
11824 | |--SEMI -> ; [1109:63]
11825 | |--EXPR -> EXPR [1110:19]
11826 | | `--METHOD_CALL -> ( [1110:19]
11827 | | |--IDENT -> verifyWarns [1110:8]
11828 | | |--ELIST -> ELIST [1110:20]
11829 | | | |--EXPR -> EXPR [1110:20]
11830 | | | | `--IDENT -> checkConfig [1110:20]
11831 | | | |--COMMA -> , [1110:31]
11832 | | | |--EXPR -> EXPR [1110:33]
11833 | | | | `--IDENT -> fileName [1110:33]
11834 | | | |--COMMA -> , [1110:41]
11835 | | | `--EXPR -> EXPR [1110:43]
11836 | | | `--IDENT -> expected [1110:43]
11837 | | `--RPAREN -> ) [1110:51]
11838 | |--SEMI -> ; [1110:52]
11839 | `--RCURLY -> } [1111:4]
11840 |--METHOD_DEF -> METHOD_DEF [1113:4]
11841 | |--MODIFIERS -> MODIFIERS [1113:4]
11842 | | |--ANNOTATION -> ANNOTATION [1113:4]
11843 | | | |--AT -> @ [1113:4]
11844 | | | `--IDENT -> Test [1113:5]
11845 | | `--LITERAL_PUBLIC -> public [1114:4]
11846 | |--TYPE -> TYPE [1114:11]
11847 | | `--LITERAL_VOID -> void [1114:11]
11848 | |--IDENT -> testValidArrayInitTwoDimensional [1114:16]
11849 | |--LPAREN -> ( [1114:48]
11850 | |--PARAMETERS -> PARAMETERS [1114:49]
11851 | |--RPAREN -> ) [1114:49]
11852 | |--LITERAL_THROWS -> throws [1114:51]
11853 | | `--IDENT -> Exception [1114:58]
11854 | `--SLIST -> { [1114:68]
11855 | |--VARIABLE_DEF -> VARIABLE_DEF [1115:8]
11856 | | |--MODIFIERS -> MODIFIERS [1115:8]
11857 | | | `--FINAL -> final [1115:8]
11858 | | |--TYPE -> TYPE [1115:14]
11859 | | | `--IDENT -> DefaultConfiguration [1115:14]
11860 | | |--IDENT -> checkConfig [1115:35]
11861 | | `--ASSIGN -> = [1115:47]
11862 | | `--EXPR -> EXPR [1115:67]
11863 | | `--METHOD_CALL -> ( [1115:67]
11864 | | |--IDENT -> createModuleConfig [1115:49]
11865 | | |--ELIST -> ELIST [1115:84]
11866 | | | `--EXPR -> EXPR [1115:84]
11867 | | | `--DOT -> . [1115:84]
11868 | | | |--IDENT -> IndentationCheck [1115:68]
11869 | | | `--LITERAL_CLASS -> class [1115:85]
11870 | | `--RPAREN -> ) [1115:90]
11871 | |--SEMI -> ; [1115:91]
11872 | |--EXPR -> EXPR [1117:32]
11873 | | `--METHOD_CALL -> ( [1117:32]
11874 | | |--DOT -> . [1117:19]
11875 | | | |--IDENT -> checkConfig [1117:8]
11876 | | | `--IDENT -> addAttribute [1117:20]
11877 | | |--ELIST -> ELIST [1117:33]
11878 | | | |--EXPR -> EXPR [1117:33]
11879 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1117:33]
11880 | | | |--COMMA -> , [1117:50]
11881 | | | `--EXPR -> EXPR [1117:52]
11882 | | | `--STRING_LITERAL -> "2" [1117:52]
11883 | | `--RPAREN -> ) [1117:55]
11884 | |--SEMI -> ; [1117:56]
11885 | |--EXPR -> EXPR [1118:32]
11886 | | `--METHOD_CALL -> ( [1118:32]
11887 | | |--DOT -> . [1118:19]
11888 | | | |--IDENT -> checkConfig [1118:8]
11889 | | | `--IDENT -> addAttribute [1118:20]
11890 | | |--ELIST -> ELIST [1118:33]
11891 | | | |--EXPR -> EXPR [1118:33]
11892 | | | | `--STRING_LITERAL -> "basicOffset" [1118:33]
11893 | | | |--COMMA -> , [1118:46]
11894 | | | `--EXPR -> EXPR [1118:48]
11895 | | | `--STRING_LITERAL -> "4" [1118:48]
11896 | | `--RPAREN -> ) [1118:51]
11897 | |--SEMI -> ; [1118:52]
11898 | |--EXPR -> EXPR [1119:32]
11899 | | `--METHOD_CALL -> ( [1119:32]
11900 | | |--DOT -> . [1119:19]
11901 | | | |--IDENT -> checkConfig [1119:8]
11902 | | | `--IDENT -> addAttribute [1119:20]
11903 | | |--ELIST -> ELIST [1119:33]
11904 | | | |--EXPR -> EXPR [1119:33]
11905 | | | | `--STRING_LITERAL -> "braceAdjustment" [1119:33]
11906 | | | |--COMMA -> , [1119:50]
11907 | | | `--EXPR -> EXPR [1119:52]
11908 | | | `--STRING_LITERAL -> "4" [1119:52]
11909 | | `--RPAREN -> ) [1119:55]
11910 | |--SEMI -> ; [1119:56]
11911 | |--EXPR -> EXPR [1120:32]
11912 | | `--METHOD_CALL -> ( [1120:32]
11913 | | |--DOT -> . [1120:19]
11914 | | | |--IDENT -> checkConfig [1120:8]
11915 | | | `--IDENT -> addAttribute [1120:20]
11916 | | |--ELIST -> ELIST [1120:33]
11917 | | | |--EXPR -> EXPR [1120:33]
11918 | | | | `--STRING_LITERAL -> "caseIndent" [1120:33]
11919 | | | |--COMMA -> , [1120:45]
11920 | | | `--EXPR -> EXPR [1120:47]
11921 | | | `--STRING_LITERAL -> "4" [1120:47]
11922 | | `--RPAREN -> ) [1120:50]
11923 | |--SEMI -> ; [1120:51]
11924 | |--EXPR -> EXPR [1121:32]
11925 | | `--METHOD_CALL -> ( [1121:32]
11926 | | |--DOT -> . [1121:19]
11927 | | | |--IDENT -> checkConfig [1121:8]
11928 | | | `--IDENT -> addAttribute [1121:20]
11929 | | |--ELIST -> ELIST [1121:33]
11930 | | | |--EXPR -> EXPR [1121:33]
11931 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1121:33]
11932 | | | |--COMMA -> , [1121:55]
11933 | | | `--EXPR -> EXPR [1121:57]
11934 | | | `--STRING_LITERAL -> "false" [1121:57]
11935 | | `--RPAREN -> ) [1121:64]
11936 | |--SEMI -> ; [1121:65]
11937 | |--EXPR -> EXPR [1122:32]
11938 | | `--METHOD_CALL -> ( [1122:32]
11939 | | |--DOT -> . [1122:19]
11940 | | | |--IDENT -> checkConfig [1122:8]
11941 | | | `--IDENT -> addAttribute [1122:20]
11942 | | |--ELIST -> ELIST [1122:33]
11943 | | | |--EXPR -> EXPR [1122:33]
11944 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1122:33]
11945 | | | |--COMMA -> , [1122:58]
11946 | | | `--EXPR -> EXPR [1122:60]
11947 | | | `--STRING_LITERAL -> "4" [1122:60]
11948 | | `--RPAREN -> ) [1122:63]
11949 | |--SEMI -> ; [1122:64]
11950 | |--EXPR -> EXPR [1123:32]
11951 | | `--METHOD_CALL -> ( [1123:32]
11952 | | |--DOT -> . [1123:19]
11953 | | | |--IDENT -> checkConfig [1123:8]
11954 | | | `--IDENT -> addAttribute [1123:20]
11955 | | |--ELIST -> ELIST [1123:33]
11956 | | | |--EXPR -> EXPR [1123:33]
11957 | | | | `--STRING_LITERAL -> "tabWidth" [1123:33]
11958 | | | |--COMMA -> , [1123:43]
11959 | | | `--EXPR -> EXPR [1123:45]
11960 | | | `--STRING_LITERAL -> "4" [1123:45]
11961 | | `--RPAREN -> ) [1123:48]
11962 | |--SEMI -> ; [1123:49]
11963 | |--EXPR -> EXPR [1124:32]
11964 | | `--METHOD_CALL -> ( [1124:32]
11965 | | |--DOT -> . [1124:19]
11966 | | | |--IDENT -> checkConfig [1124:8]
11967 | | | `--IDENT -> addAttribute [1124:20]
11968 | | |--ELIST -> ELIST [1124:33]
11969 | | | |--EXPR -> EXPR [1124:33]
11970 | | | | `--STRING_LITERAL -> "throwsIndent" [1124:33]
11971 | | | |--COMMA -> , [1124:47]
11972 | | | `--EXPR -> EXPR [1124:49]
11973 | | | `--STRING_LITERAL -> "4" [1124:49]
11974 | | `--RPAREN -> ) [1124:52]
11975 | |--SEMI -> ; [1124:53]
11976 | |--VARIABLE_DEF -> VARIABLE_DEF [1125:8]
11977 | | |--MODIFIERS -> MODIFIERS [1125:8]
11978 | | | `--FINAL -> final [1125:8]
11979 | | |--TYPE -> TYPE [1125:14]
11980 | | | `--IDENT -> String [1125:14]
11981 | | |--IDENT -> fileName [1125:21]
11982 | | `--ASSIGN -> = [1125:30]
11983 | | `--EXPR -> EXPR [1125:39]
11984 | | `--METHOD_CALL -> ( [1125:39]
11985 | | |--IDENT -> getPath [1125:32]
11986 | | |--ELIST -> ELIST [1125:40]
11987 | | | `--EXPR -> EXPR [1125:40]
11988 | | | `--STRING_LITERAL -> "InputIndentationValidArrayInitIndentTwoDimensional.java" [1125:40]
11989 | | `--RPAREN -> ) [1125:97]
11990 | |--SEMI -> ; [1125:98]
11991 | |--VARIABLE_DEF -> VARIABLE_DEF [1126:8]
11992 | | |--MODIFIERS -> MODIFIERS [1126:8]
11993 | | | `--FINAL -> final [1126:8]
11994 | | |--TYPE -> TYPE [1126:20]
11995 | | | `--ARRAY_DECLARATOR -> [ [1126:20]
11996 | | | |--IDENT -> String [1126:14]
11997 | | | `--RBRACK -> ] [1126:21]
11998 | | |--IDENT -> expected [1126:23]
11999 | | `--ASSIGN -> = [1126:32]
12000 | | `--EXPR -> EXPR [1126:44]
12001 | | `--DOT -> . [1126:44]
12002 | | |--IDENT -> CommonUtil [1126:34]
12003 | | `--IDENT -> EMPTY_STRING_ARRAY [1126:45]
12004 | |--SEMI -> ; [1126:63]
12005 | |--EXPR -> EXPR [1127:19]
12006 | | `--METHOD_CALL -> ( [1127:19]
12007 | | |--IDENT -> verifyWarns [1127:8]
12008 | | |--ELIST -> ELIST [1127:20]
12009 | | | |--EXPR -> EXPR [1127:20]
12010 | | | | `--IDENT -> checkConfig [1127:20]
12011 | | | |--COMMA -> , [1127:31]
12012 | | | |--EXPR -> EXPR [1127:33]
12013 | | | | `--IDENT -> fileName [1127:33]
12014 | | | |--COMMA -> , [1127:41]
12015 | | | `--EXPR -> EXPR [1127:43]
12016 | | | `--IDENT -> expected [1127:43]
12017 | | `--RPAREN -> ) [1127:51]
12018 | |--SEMI -> ; [1127:52]
12019 | `--RCURLY -> } [1128:4]
12020 |--METHOD_DEF -> METHOD_DEF [1130:4]
12021 | |--MODIFIERS -> MODIFIERS [1130:4]
12022 | | |--ANNOTATION -> ANNOTATION [1130:4]
12023 | | | |--AT -> @ [1130:4]
12024 | | | `--IDENT -> Test [1130:5]
12025 | | `--LITERAL_PUBLIC -> public [1131:4]
12026 | |--TYPE -> TYPE [1131:11]
12027 | | `--LITERAL_VOID -> void [1131:11]
12028 | |--IDENT -> testInvalidArrayInitTwoDimensional [1131:16]
12029 | |--LPAREN -> ( [1131:50]
12030 | |--PARAMETERS -> PARAMETERS [1131:51]
12031 | |--RPAREN -> ) [1131:51]
12032 | |--LITERAL_THROWS -> throws [1131:53]
12033 | | `--IDENT -> Exception [1131:60]
12034 | `--SLIST -> { [1131:70]
12035 | |--VARIABLE_DEF -> VARIABLE_DEF [1132:8]
12036 | | |--MODIFIERS -> MODIFIERS [1132:8]
12037 | | | `--FINAL -> final [1132:8]
12038 | | |--TYPE -> TYPE [1132:14]
12039 | | | `--IDENT -> DefaultConfiguration [1132:14]
12040 | | |--IDENT -> checkConfig [1132:35]
12041 | | `--ASSIGN -> = [1132:47]
12042 | | `--EXPR -> EXPR [1132:67]
12043 | | `--METHOD_CALL -> ( [1132:67]
12044 | | |--IDENT -> createModuleConfig [1132:49]
12045 | | |--ELIST -> ELIST [1132:84]
12046 | | | `--EXPR -> EXPR [1132:84]
12047 | | | `--DOT -> . [1132:84]
12048 | | | |--IDENT -> IndentationCheck [1132:68]
12049 | | | `--LITERAL_CLASS -> class [1132:85]
12050 | | `--RPAREN -> ) [1132:90]
12051 | |--SEMI -> ; [1132:91]
12052 | |--EXPR -> EXPR [1134:32]
12053 | | `--METHOD_CALL -> ( [1134:32]
12054 | | |--DOT -> . [1134:19]
12055 | | | |--IDENT -> checkConfig [1134:8]
12056 | | | `--IDENT -> addAttribute [1134:20]
12057 | | |--ELIST -> ELIST [1134:33]
12058 | | | |--EXPR -> EXPR [1134:33]
12059 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1134:33]
12060 | | | |--COMMA -> , [1134:50]
12061 | | | `--EXPR -> EXPR [1134:52]
12062 | | | `--STRING_LITERAL -> "2" [1134:52]
12063 | | `--RPAREN -> ) [1134:55]
12064 | |--SEMI -> ; [1134:56]
12065 | |--EXPR -> EXPR [1135:32]
12066 | | `--METHOD_CALL -> ( [1135:32]
12067 | | |--DOT -> . [1135:19]
12068 | | | |--IDENT -> checkConfig [1135:8]
12069 | | | `--IDENT -> addAttribute [1135:20]
12070 | | |--ELIST -> ELIST [1135:33]
12071 | | | |--EXPR -> EXPR [1135:33]
12072 | | | | `--STRING_LITERAL -> "basicOffset" [1135:33]
12073 | | | |--COMMA -> , [1135:46]
12074 | | | `--EXPR -> EXPR [1135:48]
12075 | | | `--STRING_LITERAL -> "4" [1135:48]
12076 | | `--RPAREN -> ) [1135:51]
12077 | |--SEMI -> ; [1135:52]
12078 | |--EXPR -> EXPR [1136:32]
12079 | | `--METHOD_CALL -> ( [1136:32]
12080 | | |--DOT -> . [1136:19]
12081 | | | |--IDENT -> checkConfig [1136:8]
12082 | | | `--IDENT -> addAttribute [1136:20]
12083 | | |--ELIST -> ELIST [1136:33]
12084 | | | |--EXPR -> EXPR [1136:33]
12085 | | | | `--STRING_LITERAL -> "braceAdjustment" [1136:33]
12086 | | | |--COMMA -> , [1136:50]
12087 | | | `--EXPR -> EXPR [1136:52]
12088 | | | `--STRING_LITERAL -> "4" [1136:52]
12089 | | `--RPAREN -> ) [1136:55]
12090 | |--SEMI -> ; [1136:56]
12091 | |--EXPR -> EXPR [1137:32]
12092 | | `--METHOD_CALL -> ( [1137:32]
12093 | | |--DOT -> . [1137:19]
12094 | | | |--IDENT -> checkConfig [1137:8]
12095 | | | `--IDENT -> addAttribute [1137:20]
12096 | | |--ELIST -> ELIST [1137:33]
12097 | | | |--EXPR -> EXPR [1137:33]
12098 | | | | `--STRING_LITERAL -> "caseIndent" [1137:33]
12099 | | | |--COMMA -> , [1137:45]
12100 | | | `--EXPR -> EXPR [1137:47]
12101 | | | `--STRING_LITERAL -> "4" [1137:47]
12102 | | `--RPAREN -> ) [1137:50]
12103 | |--SEMI -> ; [1137:51]
12104 | |--EXPR -> EXPR [1138:32]
12105 | | `--METHOD_CALL -> ( [1138:32]
12106 | | |--DOT -> . [1138:19]
12107 | | | |--IDENT -> checkConfig [1138:8]
12108 | | | `--IDENT -> addAttribute [1138:20]
12109 | | |--ELIST -> ELIST [1138:33]
12110 | | | |--EXPR -> EXPR [1138:33]
12111 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1138:33]
12112 | | | |--COMMA -> , [1138:55]
12113 | | | `--EXPR -> EXPR [1138:57]
12114 | | | `--STRING_LITERAL -> "false" [1138:57]
12115 | | `--RPAREN -> ) [1138:64]
12116 | |--SEMI -> ; [1138:65]
12117 | |--EXPR -> EXPR [1139:32]
12118 | | `--METHOD_CALL -> ( [1139:32]
12119 | | |--DOT -> . [1139:19]
12120 | | | |--IDENT -> checkConfig [1139:8]
12121 | | | `--IDENT -> addAttribute [1139:20]
12122 | | |--ELIST -> ELIST [1139:33]
12123 | | | |--EXPR -> EXPR [1139:33]
12124 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1139:33]
12125 | | | |--COMMA -> , [1139:58]
12126 | | | `--EXPR -> EXPR [1139:60]
12127 | | | `--STRING_LITERAL -> "4" [1139:60]
12128 | | `--RPAREN -> ) [1139:63]
12129 | |--SEMI -> ; [1139:64]
12130 | |--EXPR -> EXPR [1140:32]
12131 | | `--METHOD_CALL -> ( [1140:32]
12132 | | |--DOT -> . [1140:19]
12133 | | | |--IDENT -> checkConfig [1140:8]
12134 | | | `--IDENT -> addAttribute [1140:20]
12135 | | |--ELIST -> ELIST [1140:33]
12136 | | | |--EXPR -> EXPR [1140:33]
12137 | | | | `--STRING_LITERAL -> "tabWidth" [1140:33]
12138 | | | |--COMMA -> , [1140:43]
12139 | | | `--EXPR -> EXPR [1140:45]
12140 | | | `--STRING_LITERAL -> "4" [1140:45]
12141 | | `--RPAREN -> ) [1140:48]
12142 | |--SEMI -> ; [1140:49]
12143 | |--EXPR -> EXPR [1141:32]
12144 | | `--METHOD_CALL -> ( [1141:32]
12145 | | |--DOT -> . [1141:19]
12146 | | | |--IDENT -> checkConfig [1141:8]
12147 | | | `--IDENT -> addAttribute [1141:20]
12148 | | |--ELIST -> ELIST [1141:33]
12149 | | | |--EXPR -> EXPR [1141:33]
12150 | | | | `--STRING_LITERAL -> "throwsIndent" [1141:33]
12151 | | | |--COMMA -> , [1141:47]
12152 | | | `--EXPR -> EXPR [1141:49]
12153 | | | `--STRING_LITERAL -> "4" [1141:49]
12154 | | `--RPAREN -> ) [1141:52]
12155 | |--SEMI -> ; [1141:53]
12156 | |--VARIABLE_DEF -> VARIABLE_DEF [1142:8]
12157 | | |--MODIFIERS -> MODIFIERS [1142:8]
12158 | | | `--FINAL -> final [1142:8]
12159 | | |--TYPE -> TYPE [1142:14]
12160 | | | `--IDENT -> String [1142:14]
12161 | | |--IDENT -> fileName [1142:21]
12162 | | `--ASSIGN -> = [1142:30]
12163 | | `--EXPR -> EXPR [1143:19]
12164 | | `--METHOD_CALL -> ( [1143:19]
12165 | | |--IDENT -> getPath [1143:12]
12166 | | |--ELIST -> ELIST [1143:20]
12167 | | | `--EXPR -> EXPR [1143:20]
12168 | | | `--STRING_LITERAL -> "InputIndentationInvalidArrayInitIndentTwoDimensional.java" [1143:20]
12169 | | `--RPAREN -> ) [1143:79]
12170 | |--SEMI -> ; [1143:80]
12171 | |--VARIABLE_DEF -> VARIABLE_DEF [1144:8]
12172 | | |--MODIFIERS -> MODIFIERS [1144:8]
12173 | | | `--FINAL -> final [1144:8]
12174 | | |--TYPE -> TYPE [1144:20]
12175 | | | `--ARRAY_DECLARATOR -> [ [1144:20]
12176 | | | |--IDENT -> String [1144:14]
12177 | | | `--RBRACK -> ] [1144:21]
12178 | | |--IDENT -> expected [1144:23]
12179 | | `--ASSIGN -> = [1144:32]
12180 | | `--ARRAY_INIT -> { [1144:34]
12181 | | |--EXPR -> EXPR [1145:21]
12182 | | | `--PLUS -> + [1145:21]
12183 | | | |--STRING_LITERAL -> "18:5: " [1145:12]
12184 | | | `--METHOD_CALL -> ( [1145:38]
12185 | | | |--IDENT -> getCheckMessage [1145:23]
12186 | | | |--ELIST -> ELIST [1145:39]
12187 | | | | |--EXPR -> EXPR [1145:39]
12188 | | | | | `--IDENT -> MSG_ERROR_MULTI [1145:39]
12189 | | | | |--COMMA -> , [1145:54]
12190 | | | | |--EXPR -> EXPR [1146:16]
12191 | | | | | `--STRING_LITERAL -> "array initialization lcurly" [1146:16]
12192 | | | | |--COMMA -> , [1146:45]
12193 | | | | |--EXPR -> EXPR [1146:47]
12194 | | | | | `--NUM_INT -> 4 [1146:47]
12195 | | | | |--COMMA -> , [1146:48]
12196 | | | | `--EXPR -> EXPR [1146:50]
12197 | | | | `--STRING_LITERAL -> "6, 8, 18, 20, 24" [1146:50]
12198 | | | `--RPAREN -> ) [1146:68]
12199 | | |--COMMA -> , [1146:69]
12200 | | |--EXPR -> EXPR [1147:22]
12201 | | | `--PLUS -> + [1147:22]
12202 | | | |--STRING_LITERAL -> "23:10: " [1147:12]
12203 | | | `--METHOD_CALL -> ( [1147:39]
12204 | | | |--IDENT -> getCheckMessage [1147:24]
12205 | | | |--ELIST -> ELIST [1147:40]
12206 | | | | |--EXPR -> EXPR [1147:40]
12207 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [1147:40]
12208 | | | | |--COMMA -> , [1147:61]
12209 | | | | |--EXPR -> EXPR [1148:16]
12210 | | | | | `--STRING_LITERAL -> "array initialization" [1148:16]
12211 | | | | |--COMMA -> , [1148:38]
12212 | | | | |--EXPR -> EXPR [1148:40]
12213 | | | | | `--NUM_INT -> 9 [1148:40]
12214 | | | | |--COMMA -> , [1148:41]
12215 | | | | `--EXPR -> EXPR [1148:43]
12216 | | | | `--STRING_LITERAL -> "8, 10, 12, 20, 22, 24" [1148:43]
12217 | | | `--RPAREN -> ) [1148:66]
12218 | | |--COMMA -> , [1148:67]
12219 | | |--EXPR -> EXPR [1149:21]
12220 | | | `--PLUS -> + [1149:21]
12221 | | | |--STRING_LITERAL -> "26:7: " [1149:12]
12222 | | | `--METHOD_CALL -> ( [1149:38]
12223 | | | |--IDENT -> getCheckMessage [1149:23]
12224 | | | |--ELIST -> ELIST [1149:39]
12225 | | | | |--EXPR -> EXPR [1149:39]
12226 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [1149:39]
12227 | | | | |--COMMA -> , [1149:60]
12228 | | | | |--EXPR -> EXPR [1150:16]
12229 | | | | | `--STRING_LITERAL -> "array initialization" [1150:16]
12230 | | | | |--COMMA -> , [1150:38]
12231 | | | | |--EXPR -> EXPR [1150:40]
12232 | | | | | `--NUM_INT -> 6 [1150:40]
12233 | | | | |--COMMA -> , [1150:41]
12234 | | | | `--EXPR -> EXPR [1150:43]
12235 | | | | `--STRING_LITERAL -> "8, 10, 12, 20, 22, 24" [1150:43]
12236 | | | `--RPAREN -> ) [1150:66]
12237 | | |--COMMA -> , [1150:67]
12238 | | |--EXPR -> EXPR [1151:21]
12239 | | | `--PLUS -> + [1151:21]
12240 | | | |--STRING_LITERAL -> "28:5: " [1151:12]
12241 | | | `--METHOD_CALL -> ( [1151:38]
12242 | | | |--IDENT -> getCheckMessage [1151:23]
12243 | | | |--ELIST -> ELIST [1151:39]
12244 | | | | |--EXPR -> EXPR [1151:39]
12245 | | | | | `--IDENT -> MSG_ERROR_MULTI [1151:39]
12246 | | | | |--COMMA -> , [1151:54]
12247 | | | | |--EXPR -> EXPR [1152:16]
12248 | | | | | `--STRING_LITERAL -> "array initialization lcurly" [1152:16]
12249 | | | | |--COMMA -> , [1152:45]
12250 | | | | |--EXPR -> EXPR [1152:47]
12251 | | | | | `--NUM_INT -> 4 [1152:47]
12252 | | | | |--COMMA -> , [1152:48]
12253 | | | | `--EXPR -> EXPR [1152:50]
12254 | | | | `--STRING_LITERAL -> "6, 8, 18, 20, 24" [1152:50]
12255 | | | `--RPAREN -> ) [1152:68]
12256 | | |--COMMA -> , [1152:69]
12257 | | |--EXPR -> EXPR [1153:21]
12258 | | | `--PLUS -> + [1153:21]
12259 | | | |--STRING_LITERAL -> "30:5: " [1153:12]
12260 | | | `--METHOD_CALL -> ( [1153:38]
12261 | | | |--IDENT -> getCheckMessage [1153:23]
12262 | | | |--ELIST -> ELIST [1153:39]
12263 | | | | |--EXPR -> EXPR [1153:39]
12264 | | | | | `--IDENT -> MSG_ERROR_MULTI [1153:39]
12265 | | | | |--COMMA -> , [1153:54]
12266 | | | | |--EXPR -> EXPR [1154:16]
12267 | | | | | `--STRING_LITERAL -> "array initialization rcurly" [1154:16]
12268 | | | | |--COMMA -> , [1154:45]
12269 | | | | |--EXPR -> EXPR [1154:47]
12270 | | | | | `--NUM_INT -> 4 [1154:47]
12271 | | | | |--COMMA -> , [1154:48]
12272 | | | | `--EXPR -> EXPR [1154:50]
12273 | | | | `--STRING_LITERAL -> "6, 8, 18, 20, 24" [1154:50]
12274 | | | `--RPAREN -> ) [1154:68]
12275 | | |--COMMA -> , [1154:69]
12276 | | `--RCURLY -> } [1156:8]
12277 | |--SEMI -> ; [1156:9]
12278 | |--EXPR -> EXPR [1157:19]
12279 | | `--METHOD_CALL -> ( [1157:19]
12280 | | |--IDENT -> verifyWarns [1157:8]
12281 | | |--ELIST -> ELIST [1157:20]
12282 | | | |--EXPR -> EXPR [1157:20]
12283 | | | | `--IDENT -> checkConfig [1157:20]
12284 | | | |--COMMA -> , [1157:31]
12285 | | | |--EXPR -> EXPR [1157:33]
12286 | | | | `--IDENT -> fileName [1157:33]
12287 | | | |--COMMA -> , [1157:41]
12288 | | | `--EXPR -> EXPR [1157:43]
12289 | | | `--IDENT -> expected [1157:43]
12290 | | `--RPAREN -> ) [1157:51]
12291 | |--SEMI -> ; [1157:52]
12292 | `--RCURLY -> } [1158:4]
12293 |--METHOD_DEF -> METHOD_DEF [1160:4]
12294 | |--MODIFIERS -> MODIFIERS [1160:4]
12295 | | |--ANNOTATION -> ANNOTATION [1160:4]
12296 | | | |--AT -> @ [1160:4]
12297 | | | `--IDENT -> Test [1160:5]
12298 | | `--LITERAL_PUBLIC -> public [1161:4]
12299 | |--TYPE -> TYPE [1161:11]
12300 | | `--LITERAL_VOID -> void [1161:11]
12301 | |--IDENT -> testValidArrayInit [1161:16]
12302 | |--LPAREN -> ( [1161:34]
12303 | |--PARAMETERS -> PARAMETERS [1161:35]
12304 | |--RPAREN -> ) [1161:35]
12305 | |--LITERAL_THROWS -> throws [1162:12]
12306 | | `--IDENT -> Exception [1162:19]
12307 | `--SLIST -> { [1162:29]
12308 | |--VARIABLE_DEF -> VARIABLE_DEF [1163:8]
12309 | | |--MODIFIERS -> MODIFIERS [1163:8]
12310 | | | `--FINAL -> final [1163:8]
12311 | | |--TYPE -> TYPE [1163:14]
12312 | | | `--IDENT -> DefaultConfiguration [1163:14]
12313 | | |--IDENT -> checkConfig [1163:35]
12314 | | `--ASSIGN -> = [1163:47]
12315 | | `--EXPR -> EXPR [1163:67]
12316 | | `--METHOD_CALL -> ( [1163:67]
12317 | | |--IDENT -> createModuleConfig [1163:49]
12318 | | |--ELIST -> ELIST [1163:84]
12319 | | | `--EXPR -> EXPR [1163:84]
12320 | | | `--DOT -> . [1163:84]
12321 | | | |--IDENT -> IndentationCheck [1163:68]
12322 | | | `--LITERAL_CLASS -> class [1163:85]
12323 | | `--RPAREN -> ) [1163:90]
12324 | |--SEMI -> ; [1163:91]
12325 | |--EXPR -> EXPR [1165:32]
12326 | | `--METHOD_CALL -> ( [1165:32]
12327 | | |--DOT -> . [1165:19]
12328 | | | |--IDENT -> checkConfig [1165:8]
12329 | | | `--IDENT -> addAttribute [1165:20]
12330 | | |--ELIST -> ELIST [1165:33]
12331 | | | |--EXPR -> EXPR [1165:33]
12332 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1165:33]
12333 | | | |--COMMA -> , [1165:50]
12334 | | | `--EXPR -> EXPR [1165:52]
12335 | | | `--STRING_LITERAL -> "2" [1165:52]
12336 | | `--RPAREN -> ) [1165:55]
12337 | |--SEMI -> ; [1165:56]
12338 | |--EXPR -> EXPR [1166:32]
12339 | | `--METHOD_CALL -> ( [1166:32]
12340 | | |--DOT -> . [1166:19]
12341 | | | |--IDENT -> checkConfig [1166:8]
12342 | | | `--IDENT -> addAttribute [1166:20]
12343 | | |--ELIST -> ELIST [1166:33]
12344 | | | |--EXPR -> EXPR [1166:33]
12345 | | | | `--STRING_LITERAL -> "basicOffset" [1166:33]
12346 | | | |--COMMA -> , [1166:46]
12347 | | | `--EXPR -> EXPR [1166:48]
12348 | | | `--STRING_LITERAL -> "2" [1166:48]
12349 | | `--RPAREN -> ) [1166:51]
12350 | |--SEMI -> ; [1166:52]
12351 | |--EXPR -> EXPR [1167:32]
12352 | | `--METHOD_CALL -> ( [1167:32]
12353 | | |--DOT -> . [1167:19]
12354 | | | |--IDENT -> checkConfig [1167:8]
12355 | | | `--IDENT -> addAttribute [1167:20]
12356 | | |--ELIST -> ELIST [1167:33]
12357 | | | |--EXPR -> EXPR [1167:33]
12358 | | | | `--STRING_LITERAL -> "braceAdjustment" [1167:33]
12359 | | | |--COMMA -> , [1167:50]
12360 | | | `--EXPR -> EXPR [1167:52]
12361 | | | `--STRING_LITERAL -> "2" [1167:52]
12362 | | `--RPAREN -> ) [1167:55]
12363 | |--SEMI -> ; [1167:56]
12364 | |--EXPR -> EXPR [1168:32]
12365 | | `--METHOD_CALL -> ( [1168:32]
12366 | | |--DOT -> . [1168:19]
12367 | | | |--IDENT -> checkConfig [1168:8]
12368 | | | `--IDENT -> addAttribute [1168:20]
12369 | | |--ELIST -> ELIST [1168:33]
12370 | | | |--EXPR -> EXPR [1168:33]
12371 | | | | `--STRING_LITERAL -> "caseIndent" [1168:33]
12372 | | | |--COMMA -> , [1168:45]
12373 | | | `--EXPR -> EXPR [1168:47]
12374 | | | `--STRING_LITERAL -> "2" [1168:47]
12375 | | `--RPAREN -> ) [1168:50]
12376 | |--SEMI -> ; [1168:51]
12377 | |--EXPR -> EXPR [1169:32]
12378 | | `--METHOD_CALL -> ( [1169:32]
12379 | | |--DOT -> . [1169:19]
12380 | | | |--IDENT -> checkConfig [1169:8]
12381 | | | `--IDENT -> addAttribute [1169:20]
12382 | | |--ELIST -> ELIST [1169:33]
12383 | | | |--EXPR -> EXPR [1169:33]
12384 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1169:33]
12385 | | | |--COMMA -> , [1169:55]
12386 | | | `--EXPR -> EXPR [1169:57]
12387 | | | `--STRING_LITERAL -> "false" [1169:57]
12388 | | `--RPAREN -> ) [1169:64]
12389 | |--SEMI -> ; [1169:65]
12390 | |--EXPR -> EXPR [1170:32]
12391 | | `--METHOD_CALL -> ( [1170:32]
12392 | | |--DOT -> . [1170:19]
12393 | | | |--IDENT -> checkConfig [1170:8]
12394 | | | `--IDENT -> addAttribute [1170:20]
12395 | | |--ELIST -> ELIST [1170:33]
12396 | | | |--EXPR -> EXPR [1170:33]
12397 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1170:33]
12398 | | | |--COMMA -> , [1170:58]
12399 | | | `--EXPR -> EXPR [1170:60]
12400 | | | `--STRING_LITERAL -> "4" [1170:60]
12401 | | `--RPAREN -> ) [1170:63]
12402 | |--SEMI -> ; [1170:64]
12403 | |--EXPR -> EXPR [1171:32]
12404 | | `--METHOD_CALL -> ( [1171:32]
12405 | | |--DOT -> . [1171:19]
12406 | | | |--IDENT -> checkConfig [1171:8]
12407 | | | `--IDENT -> addAttribute [1171:20]
12408 | | |--ELIST -> ELIST [1171:33]
12409 | | | |--EXPR -> EXPR [1171:33]
12410 | | | | `--STRING_LITERAL -> "tabWidth" [1171:33]
12411 | | | |--COMMA -> , [1171:43]
12412 | | | `--EXPR -> EXPR [1171:45]
12413 | | | `--STRING_LITERAL -> "4" [1171:45]
12414 | | `--RPAREN -> ) [1171:48]
12415 | |--SEMI -> ; [1171:49]
12416 | |--EXPR -> EXPR [1172:32]
12417 | | `--METHOD_CALL -> ( [1172:32]
12418 | | |--DOT -> . [1172:19]
12419 | | | |--IDENT -> checkConfig [1172:8]
12420 | | | `--IDENT -> addAttribute [1172:20]
12421 | | |--ELIST -> ELIST [1172:33]
12422 | | | |--EXPR -> EXPR [1172:33]
12423 | | | | `--STRING_LITERAL -> "throwsIndent" [1172:33]
12424 | | | |--COMMA -> , [1172:47]
12425 | | | `--EXPR -> EXPR [1172:49]
12426 | | | `--STRING_LITERAL -> "4" [1172:49]
12427 | | `--RPAREN -> ) [1172:52]
12428 | |--SEMI -> ; [1172:53]
12429 | |--VARIABLE_DEF -> VARIABLE_DEF [1173:8]
12430 | | |--MODIFIERS -> MODIFIERS [1173:8]
12431 | | | `--FINAL -> final [1173:8]
12432 | | |--TYPE -> TYPE [1173:14]
12433 | | | `--IDENT -> String [1173:14]
12434 | | |--IDENT -> fileName [1173:21]
12435 | | `--ASSIGN -> = [1173:30]
12436 | | `--EXPR -> EXPR [1173:39]
12437 | | `--METHOD_CALL -> ( [1173:39]
12438 | | |--IDENT -> getPath [1173:32]
12439 | | |--ELIST -> ELIST [1173:40]
12440 | | | `--EXPR -> EXPR [1173:40]
12441 | | | `--STRING_LITERAL -> "InputIndentationValidArrayInitIndentTwo.java" [1173:40]
12442 | | `--RPAREN -> ) [1173:86]
12443 | |--SEMI -> ; [1173:87]
12444 | |--VARIABLE_DEF -> VARIABLE_DEF [1174:8]
12445 | | |--MODIFIERS -> MODIFIERS [1174:8]
12446 | | | `--FINAL -> final [1174:8]
12447 | | |--TYPE -> TYPE [1174:20]
12448 | | | `--ARRAY_DECLARATOR -> [ [1174:20]
12449 | | | |--IDENT -> String [1174:14]
12450 | | | `--RBRACK -> ] [1174:21]
12451 | | |--IDENT -> expected [1174:23]
12452 | | `--ASSIGN -> = [1174:32]
12453 | | `--EXPR -> EXPR [1174:44]
12454 | | `--DOT -> . [1174:44]
12455 | | |--IDENT -> CommonUtil [1174:34]
12456 | | `--IDENT -> EMPTY_STRING_ARRAY [1174:45]
12457 | |--SEMI -> ; [1174:63]
12458 | |--EXPR -> EXPR [1175:19]
12459 | | `--METHOD_CALL -> ( [1175:19]
12460 | | |--IDENT -> verifyWarns [1175:8]
12461 | | |--ELIST -> ELIST [1175:20]
12462 | | | |--EXPR -> EXPR [1175:20]
12463 | | | | `--IDENT -> checkConfig [1175:20]
12464 | | | |--COMMA -> , [1175:31]
12465 | | | |--EXPR -> EXPR [1175:33]
12466 | | | | `--IDENT -> fileName [1175:33]
12467 | | | |--COMMA -> , [1175:41]
12468 | | | `--EXPR -> EXPR [1175:43]
12469 | | | `--IDENT -> expected [1175:43]
12470 | | `--RPAREN -> ) [1175:51]
12471 | |--SEMI -> ; [1175:52]
12472 | `--RCURLY -> } [1176:4]
12473 |--METHOD_DEF -> METHOD_DEF [1178:4]
12474 | |--MODIFIERS -> MODIFIERS [1178:4]
12475 | | |--ANNOTATION -> ANNOTATION [1178:4]
12476 | | | |--AT -> @ [1178:4]
12477 | | | `--IDENT -> Test [1178:5]
12478 | | `--LITERAL_PUBLIC -> public [1179:4]
12479 | |--TYPE -> TYPE [1179:11]
12480 | | `--LITERAL_VOID -> void [1179:11]
12481 | |--IDENT -> testInvalidArrayInitWithChecker [1179:16]
12482 | |--LPAREN -> ( [1179:47]
12483 | |--PARAMETERS -> PARAMETERS [1179:48]
12484 | |--RPAREN -> ) [1179:48]
12485 | |--LITERAL_THROWS -> throws [1180:12]
12486 | | `--IDENT -> Exception [1180:19]
12487 | `--SLIST -> { [1180:29]
12488 | |--VARIABLE_DEF -> VARIABLE_DEF [1181:8]
12489 | | |--MODIFIERS -> MODIFIERS [1181:8]
12490 | | | `--FINAL -> final [1181:8]
12491 | | |--TYPE -> TYPE [1181:14]
12492 | | | `--IDENT -> DefaultConfiguration [1181:14]
12493 | | |--IDENT -> checkConfig [1181:35]
12494 | | `--ASSIGN -> = [1181:47]
12495 | | `--EXPR -> EXPR [1181:67]
12496 | | `--METHOD_CALL -> ( [1181:67]
12497 | | |--IDENT -> createModuleConfig [1181:49]
12498 | | |--ELIST -> ELIST [1181:84]
12499 | | | `--EXPR -> EXPR [1181:84]
12500 | | | `--DOT -> . [1181:84]
12501 | | | |--IDENT -> IndentationCheck [1181:68]
12502 | | | `--LITERAL_CLASS -> class [1181:85]
12503 | | `--RPAREN -> ) [1181:90]
12504 | |--SEMI -> ; [1181:91]
12505 | |--EXPR -> EXPR [1183:32]
12506 | | `--METHOD_CALL -> ( [1183:32]
12507 | | |--DOT -> . [1183:19]
12508 | | | |--IDENT -> checkConfig [1183:8]
12509 | | | `--IDENT -> addAttribute [1183:20]
12510 | | |--ELIST -> ELIST [1183:33]
12511 | | | |--EXPR -> EXPR [1183:33]
12512 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1183:33]
12513 | | | |--COMMA -> , [1183:50]
12514 | | | `--EXPR -> EXPR [1183:52]
12515 | | | `--STRING_LITERAL -> "4" [1183:52]
12516 | | `--RPAREN -> ) [1183:55]
12517 | |--SEMI -> ; [1183:56]
12518 | |--EXPR -> EXPR [1184:32]
12519 | | `--METHOD_CALL -> ( [1184:32]
12520 | | |--DOT -> . [1184:19]
12521 | | | |--IDENT -> checkConfig [1184:8]
12522 | | | `--IDENT -> addAttribute [1184:20]
12523 | | |--ELIST -> ELIST [1184:33]
12524 | | | |--EXPR -> EXPR [1184:33]
12525 | | | | `--STRING_LITERAL -> "basicOffset" [1184:33]
12526 | | | |--COMMA -> , [1184:46]
12527 | | | `--EXPR -> EXPR [1184:48]
12528 | | | `--STRING_LITERAL -> "4" [1184:48]
12529 | | `--RPAREN -> ) [1184:51]
12530 | |--SEMI -> ; [1184:52]
12531 | |--EXPR -> EXPR [1185:32]
12532 | | `--METHOD_CALL -> ( [1185:32]
12533 | | |--DOT -> . [1185:19]
12534 | | | |--IDENT -> checkConfig [1185:8]
12535 | | | `--IDENT -> addAttribute [1185:20]
12536 | | |--ELIST -> ELIST [1185:33]
12537 | | | |--EXPR -> EXPR [1185:33]
12538 | | | | `--STRING_LITERAL -> "braceAdjustment" [1185:33]
12539 | | | |--COMMA -> , [1185:50]
12540 | | | `--EXPR -> EXPR [1185:52]
12541 | | | `--STRING_LITERAL -> "0" [1185:52]
12542 | | `--RPAREN -> ) [1185:55]
12543 | |--SEMI -> ; [1185:56]
12544 | |--EXPR -> EXPR [1186:32]
12545 | | `--METHOD_CALL -> ( [1186:32]
12546 | | |--DOT -> . [1186:19]
12547 | | | |--IDENT -> checkConfig [1186:8]
12548 | | | `--IDENT -> addAttribute [1186:20]
12549 | | |--ELIST -> ELIST [1186:33]
12550 | | | |--EXPR -> EXPR [1186:33]
12551 | | | | `--STRING_LITERAL -> "caseIndent" [1186:33]
12552 | | | |--COMMA -> , [1186:45]
12553 | | | `--EXPR -> EXPR [1186:47]
12554 | | | `--STRING_LITERAL -> "4" [1186:47]
12555 | | `--RPAREN -> ) [1186:50]
12556 | |--SEMI -> ; [1186:51]
12557 | |--EXPR -> EXPR [1187:32]
12558 | | `--METHOD_CALL -> ( [1187:32]
12559 | | |--DOT -> . [1187:19]
12560 | | | |--IDENT -> checkConfig [1187:8]
12561 | | | `--IDENT -> addAttribute [1187:20]
12562 | | |--ELIST -> ELIST [1187:33]
12563 | | | |--EXPR -> EXPR [1187:33]
12564 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1187:33]
12565 | | | |--COMMA -> , [1187:55]
12566 | | | `--EXPR -> EXPR [1187:57]
12567 | | | `--STRING_LITERAL -> "false" [1187:57]
12568 | | `--RPAREN -> ) [1187:64]
12569 | |--SEMI -> ; [1187:65]
12570 | |--EXPR -> EXPR [1188:32]
12571 | | `--METHOD_CALL -> ( [1188:32]
12572 | | |--DOT -> . [1188:19]
12573 | | | |--IDENT -> checkConfig [1188:8]
12574 | | | `--IDENT -> addAttribute [1188:20]
12575 | | |--ELIST -> ELIST [1188:33]
12576 | | | |--EXPR -> EXPR [1188:33]
12577 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1188:33]
12578 | | | |--COMMA -> , [1188:58]
12579 | | | `--EXPR -> EXPR [1188:60]
12580 | | | `--STRING_LITERAL -> "4" [1188:60]
12581 | | `--RPAREN -> ) [1188:63]
12582 | |--SEMI -> ; [1188:64]
12583 | |--EXPR -> EXPR [1189:32]
12584 | | `--METHOD_CALL -> ( [1189:32]
12585 | | |--DOT -> . [1189:19]
12586 | | | |--IDENT -> checkConfig [1189:8]
12587 | | | `--IDENT -> addAttribute [1189:20]
12588 | | |--ELIST -> ELIST [1189:33]
12589 | | | |--EXPR -> EXPR [1189:33]
12590 | | | | `--STRING_LITERAL -> "tabWidth" [1189:33]
12591 | | | |--COMMA -> , [1189:43]
12592 | | | `--EXPR -> EXPR [1189:45]
12593 | | | `--STRING_LITERAL -> "4" [1189:45]
12594 | | `--RPAREN -> ) [1189:48]
12595 | |--SEMI -> ; [1189:49]
12596 | |--EXPR -> EXPR [1190:32]
12597 | | `--METHOD_CALL -> ( [1190:32]
12598 | | |--DOT -> . [1190:19]
12599 | | | |--IDENT -> checkConfig [1190:8]
12600 | | | `--IDENT -> addAttribute [1190:20]
12601 | | |--ELIST -> ELIST [1190:33]
12602 | | | |--EXPR -> EXPR [1190:33]
12603 | | | | `--STRING_LITERAL -> "throwsIndent" [1190:33]
12604 | | | |--COMMA -> , [1190:47]
12605 | | | `--EXPR -> EXPR [1190:49]
12606 | | | `--STRING_LITERAL -> "4" [1190:49]
12607 | | `--RPAREN -> ) [1190:52]
12608 | |--SEMI -> ; [1190:53]
12609 | |--VARIABLE_DEF -> VARIABLE_DEF [1191:8]
12610 | | |--MODIFIERS -> MODIFIERS [1191:8]
12611 | | | `--FINAL -> final [1191:8]
12612 | | |--TYPE -> TYPE [1191:14]
12613 | | | `--IDENT -> String [1191:14]
12614 | | |--IDENT -> fileName [1191:21]
12615 | | `--ASSIGN -> = [1191:30]
12616 | | `--EXPR -> EXPR [1191:39]
12617 | | `--METHOD_CALL -> ( [1191:39]
12618 | | |--IDENT -> getPath [1191:32]
12619 | | |--ELIST -> ELIST [1191:40]
12620 | | | `--EXPR -> EXPR [1191:40]
12621 | | | `--STRING_LITERAL -> "InputIndentationInvalidArrayInitIndent.java" [1191:40]
12622 | | `--RPAREN -> ) [1191:85]
12623 | |--SEMI -> ; [1191:86]
12624 | |--VARIABLE_DEF -> VARIABLE_DEF [1192:8]
12625 | | |--MODIFIERS -> MODIFIERS [1192:8]
12626 | | | `--FINAL -> final [1192:8]
12627 | | |--TYPE -> TYPE [1192:20]
12628 | | | `--ARRAY_DECLARATOR -> [ [1192:20]
12629 | | | |--IDENT -> String [1192:14]
12630 | | | `--RBRACK -> ] [1192:21]
12631 | | |--IDENT -> expected [1192:23]
12632 | | `--ASSIGN -> = [1192:32]
12633 | | `--ARRAY_INIT -> { [1192:34]
12634 | | |--EXPR -> EXPR [1193:21]
12635 | | | `--PLUS -> + [1193:21]
12636 | | | |--STRING_LITERAL -> "21:3: " [1193:12]
12637 | | | `--METHOD_CALL -> ( [1193:38]
12638 | | | |--IDENT -> getCheckMessage [1193:23]
12639 | | | |--ELIST -> ELIST [1193:39]
12640 | | | | |--EXPR -> EXPR [1193:39]
12641 | | | | | `--IDENT -> MSG_ERROR [1193:39]
12642 | | | | |--COMMA -> , [1193:48]
12643 | | | | |--EXPR -> EXPR [1193:50]
12644 | | | | | `--STRING_LITERAL -> "member def type" [1193:50]
12645 | | | | |--COMMA -> , [1193:67]
12646 | | | | |--EXPR -> EXPR [1193:69]
12647 | | | | | `--NUM_INT -> 2 [1193:69]
12648 | | | | |--COMMA -> , [1193:70]
12649 | | | | `--EXPR -> EXPR [1193:72]
12650 | | | | `--NUM_INT -> 4 [1193:72]
12651 | | | `--RPAREN -> ) [1193:73]
12652 | | |--COMMA -> , [1193:74]
12653 | | |--EXPR -> EXPR [1194:21]
12654 | | | `--PLUS -> + [1194:21]
12655 | | | |--STRING_LITERAL -> "22:7: " [1194:12]
12656 | | | `--METHOD_CALL -> ( [1194:38]
12657 | | | |--IDENT -> getCheckMessage [1194:23]
12658 | | | |--ELIST -> ELIST [1194:39]
12659 | | | | |--EXPR -> EXPR [1194:39]
12660 | | | | | `--IDENT -> MSG_ERROR [1194:39]
12661 | | | | |--COMMA -> , [1194:48]
12662 | | | | |--EXPR -> EXPR [1194:50]
12663 | | | | | `--STRING_LITERAL -> "member def type" [1194:50]
12664 | | | | |--COMMA -> , [1194:67]
12665 | | | | |--EXPR -> EXPR [1194:69]
12666 | | | | | `--NUM_INT -> 6 [1194:69]
12667 | | | | |--COMMA -> , [1194:70]
12668 | | | | `--EXPR -> EXPR [1194:72]
12669 | | | | `--NUM_INT -> 4 [1194:72]
12670 | | | `--RPAREN -> ) [1194:73]
12671 | | |--COMMA -> , [1194:74]
12672 | | |--EXPR -> EXPR [1195:21]
12673 | | | `--PLUS -> + [1195:21]
12674 | | | |--STRING_LITERAL -> "24:3: " [1195:12]
12675 | | | `--METHOD_CALL -> ( [1195:38]
12676 | | | |--IDENT -> getCheckMessage [1195:23]
12677 | | | |--ELIST -> ELIST [1195:39]
12678 | | | | |--EXPR -> EXPR [1195:39]
12679 | | | | | `--IDENT -> MSG_ERROR [1195:39]
12680 | | | | |--COMMA -> , [1195:48]
12681 | | | | |--EXPR -> EXPR [1195:50]
12682 | | | | | `--STRING_LITERAL -> "member def type" [1195:50]
12683 | | | | |--COMMA -> , [1195:67]
12684 | | | | |--EXPR -> EXPR [1195:69]
12685 | | | | | `--NUM_INT -> 2 [1195:69]
12686 | | | | |--COMMA -> , [1195:70]
12687 | | | | `--EXPR -> EXPR [1195:72]
12688 | | | | `--NUM_INT -> 4 [1195:72]
12689 | | | `--RPAREN -> ) [1195:73]
12690 | | |--COMMA -> , [1195:74]
12691 | | |--EXPR -> EXPR [1196:21]
12692 | | | `--PLUS -> + [1196:21]
12693 | | | |--STRING_LITERAL -> "28:7: " [1196:12]
12694 | | | `--METHOD_CALL -> ( [1196:38]
12695 | | | |--IDENT -> getCheckMessage [1196:23]
12696 | | | |--ELIST -> ELIST [1196:39]
12697 | | | | |--EXPR -> EXPR [1196:39]
12698 | | | | | `--IDENT -> MSG_ERROR [1196:39]
12699 | | | | |--COMMA -> , [1196:48]
12700 | | | | |--EXPR -> EXPR [1196:50]
12701 | | | | | `--STRING_LITERAL -> "member def type" [1196:50]
12702 | | | | |--COMMA -> , [1196:67]
12703 | | | | |--EXPR -> EXPR [1196:69]
12704 | | | | | `--NUM_INT -> 6 [1196:69]
12705 | | | | |--COMMA -> , [1196:70]
12706 | | | | `--EXPR -> EXPR [1196:72]
12707 | | | | `--NUM_INT -> 4 [1196:72]
12708 | | | `--RPAREN -> ) [1196:73]
12709 | | |--COMMA -> , [1196:74]
12710 | | |--EXPR -> EXPR [1197:21]
12711 | | | `--PLUS -> + [1197:21]
12712 | | | |--STRING_LITERAL -> "29:9: " [1197:12]
12713 | | | `--METHOD_CALL -> ( [1197:38]
12714 | | | |--IDENT -> getCheckMessage [1197:23]
12715 | | | |--ELIST -> ELIST [1197:39]
12716 | | | | |--EXPR -> EXPR [1197:39]
12717 | | | | | `--IDENT -> MSG_CHILD_ERROR [1197:39]
12718 | | | | |--COMMA -> , [1197:54]
12719 | | | | |--EXPR -> EXPR [1197:56]
12720 | | | | | `--STRING_LITERAL -> "array initialization" [1197:56]
12721 | | | | |--COMMA -> , [1197:78]
12722 | | | | |--EXPR -> EXPR [1197:80]
12723 | | | | | `--NUM_INT -> 8 [1197:80]
12724 | | | | |--COMMA -> , [1197:81]
12725 | | | | `--EXPR -> EXPR [1197:83]
12726 | | | | `--NUM_INT -> 10 [1197:83]
12727 | | | `--RPAREN -> ) [1197:85]
12728 | | |--COMMA -> , [1197:86]
12729 | | |--EXPR -> EXPR [1198:21]
12730 | | | `--PLUS -> + [1198:21]
12731 | | | |--STRING_LITERAL -> "30:5: " [1198:12]
12732 | | | `--METHOD_CALL -> ( [1198:38]
12733 | | | |--IDENT -> getCheckMessage [1198:23]
12734 | | | |--ELIST -> ELIST [1198:39]
12735 | | | | |--EXPR -> EXPR [1198:39]
12736 | | | | | `--IDENT -> MSG_ERROR_MULTI [1198:39]
12737 | | | | |--COMMA -> , [1198:54]
12738 | | | | |--EXPR -> EXPR [1198:56]
12739 | | | | | `--STRING_LITERAL -> "array initialization rcurly" [1198:56]
12740 | | | | |--COMMA -> , [1198:85]
12741 | | | | |--EXPR -> EXPR [1198:87]
12742 | | | | | `--NUM_INT -> 4 [1198:87]
12743 | | | | |--COMMA -> , [1198:88]
12744 | | | | `--EXPR -> EXPR [1198:90]
12745 | | | | `--STRING_LITERAL -> "6, 10" [1198:90]
12746 | | | `--RPAREN -> ) [1198:97]
12747 | | |--COMMA -> , [1198:98]
12748 | | |--EXPR -> EXPR [1199:22]
12749 | | | `--PLUS -> + [1199:22]
12750 | | | |--STRING_LITERAL -> "33:10: " [1199:12]
12751 | | | `--METHOD_CALL -> ( [1199:39]
12752 | | | |--IDENT -> getCheckMessage [1199:24]
12753 | | | |--ELIST -> ELIST [1199:40]
12754 | | | | |--EXPR -> EXPR [1199:40]
12755 | | | | | `--IDENT -> MSG_CHILD_ERROR [1199:40]
12756 | | | | |--COMMA -> , [1199:55]
12757 | | | | |--EXPR -> EXPR [1199:57]
12758 | | | | | `--STRING_LITERAL -> "array initialization" [1199:57]
12759 | | | | |--COMMA -> , [1199:79]
12760 | | | | |--EXPR -> EXPR [1199:81]
12761 | | | | | `--NUM_INT -> 9 [1199:81]
12762 | | | | |--COMMA -> , [1199:82]
12763 | | | | `--EXPR -> EXPR [1199:84]
12764 | | | | `--NUM_INT -> 8 [1199:84]
12765 | | | `--RPAREN -> ) [1199:85]
12766 | | |--COMMA -> , [1199:86]
12767 | | |--EXPR -> EXPR [1200:21]
12768 | | | `--PLUS -> + [1200:21]
12769 | | | |--STRING_LITERAL -> "34:8: " [1200:12]
12770 | | | `--METHOD_CALL -> ( [1200:38]
12771 | | | |--IDENT -> getCheckMessage [1200:23]
12772 | | | |--ELIST -> ELIST [1200:39]
12773 | | | | |--EXPR -> EXPR [1200:39]
12774 | | | | | `--IDENT -> MSG_CHILD_ERROR [1200:39]
12775 | | | | |--COMMA -> , [1200:54]
12776 | | | | |--EXPR -> EXPR [1200:56]
12777 | | | | | `--STRING_LITERAL -> "array initialization" [1200:56]
12778 | | | | |--COMMA -> , [1200:78]
12779 | | | | |--EXPR -> EXPR [1200:80]
12780 | | | | | `--NUM_INT -> 7 [1200:80]
12781 | | | | |--COMMA -> , [1200:81]
12782 | | | | `--EXPR -> EXPR [1200:83]
12783 | | | | `--NUM_INT -> 8 [1200:83]
12784 | | | `--RPAREN -> ) [1200:84]
12785 | | |--COMMA -> , [1200:85]
12786 | | |--EXPR -> EXPR [1201:22]
12787 | | | `--PLUS -> + [1201:22]
12788 | | | |--STRING_LITERAL -> "35:10: " [1201:12]
12789 | | | `--METHOD_CALL -> ( [1201:39]
12790 | | | |--IDENT -> getCheckMessage [1201:24]
12791 | | | |--ELIST -> ELIST [1201:40]
12792 | | | | |--EXPR -> EXPR [1201:40]
12793 | | | | | `--IDENT -> MSG_CHILD_ERROR [1201:40]
12794 | | | | |--COMMA -> , [1201:55]
12795 | | | | |--EXPR -> EXPR [1201:57]
12796 | | | | | `--STRING_LITERAL -> "array initialization" [1201:57]
12797 | | | | |--COMMA -> , [1201:79]
12798 | | | | |--EXPR -> EXPR [1201:81]
12799 | | | | | `--NUM_INT -> 9 [1201:81]
12800 | | | | |--COMMA -> , [1201:82]
12801 | | | | `--EXPR -> EXPR [1201:84]
12802 | | | | `--NUM_INT -> 8 [1201:84]
12803 | | | `--RPAREN -> ) [1201:85]
12804 | | |--COMMA -> , [1201:86]
12805 | | |--EXPR -> EXPR [1202:21]
12806 | | | `--PLUS -> + [1202:21]
12807 | | | |--STRING_LITERAL -> "40:3: " [1202:12]
12808 | | | `--METHOD_CALL -> ( [1202:38]
12809 | | | |--IDENT -> getCheckMessage [1202:23]
12810 | | | |--ELIST -> ELIST [1202:39]
12811 | | | | |--EXPR -> EXPR [1202:39]
12812 | | | | | `--IDENT -> MSG_ERROR_MULTI [1202:39]
12813 | | | | |--COMMA -> , [1202:54]
12814 | | | | |--EXPR -> EXPR [1202:56]
12815 | | | | | `--STRING_LITERAL -> "array initialization lcurly" [1202:56]
12816 | | | | |--COMMA -> , [1202:85]
12817 | | | | |--EXPR -> EXPR [1202:87]
12818 | | | | | `--NUM_INT -> 2 [1202:87]
12819 | | | | |--COMMA -> , [1202:88]
12820 | | | | `--EXPR -> EXPR [1202:90]
12821 | | | | `--STRING_LITERAL -> "4, 8" [1202:90]
12822 | | | `--RPAREN -> ) [1202:96]
12823 | | |--COMMA -> , [1202:97]
12824 | | |--EXPR -> EXPR [1203:21]
12825 | | | `--PLUS -> + [1203:21]
12826 | | | |--STRING_LITERAL -> "44:7: " [1203:12]
12827 | | | `--METHOD_CALL -> ( [1203:38]
12828 | | | |--IDENT -> getCheckMessage [1203:23]
12829 | | | |--ELIST -> ELIST [1203:39]
12830 | | | | |--EXPR -> EXPR [1203:39]
12831 | | | | | `--IDENT -> MSG_ERROR_MULTI [1203:39]
12832 | | | | |--COMMA -> , [1203:54]
12833 | | | | |--EXPR -> EXPR [1203:56]
12834 | | | | | `--STRING_LITERAL -> "array initialization rcurly" [1203:56]
12835 | | | | |--COMMA -> , [1203:85]
12836 | | | | |--EXPR -> EXPR [1203:87]
12837 | | | | | `--NUM_INT -> 6 [1203:87]
12838 | | | | |--COMMA -> , [1203:88]
12839 | | | | `--EXPR -> EXPR [1203:90]
12840 | | | | `--STRING_LITERAL -> "4, 8" [1203:90]
12841 | | | `--RPAREN -> ) [1203:96]
12842 | | |--COMMA -> , [1203:97]
12843 | | |--EXPR -> EXPR [1204:21]
12844 | | | `--PLUS -> + [1204:21]
12845 | | | |--STRING_LITERAL -> "48:3: " [1204:12]
12846 | | | `--METHOD_CALL -> ( [1204:38]
12847 | | | |--IDENT -> getCheckMessage [1204:23]
12848 | | | |--ELIST -> ELIST [1204:39]
12849 | | | | |--EXPR -> EXPR [1204:39]
12850 | | | | | `--IDENT -> MSG_ERROR_MULTI [1204:39]
12851 | | | | |--COMMA -> , [1204:54]
12852 | | | | |--EXPR -> EXPR [1204:56]
12853 | | | | | `--STRING_LITERAL -> "array initialization lcurly" [1204:56]
12854 | | | | |--COMMA -> , [1204:85]
12855 | | | | |--EXPR -> EXPR [1204:87]
12856 | | | | | `--NUM_INT -> 2 [1204:87]
12857 | | | | |--COMMA -> , [1204:88]
12858 | | | | `--EXPR -> EXPR [1204:90]
12859 | | | | `--STRING_LITERAL -> "4, 8" [1204:90]
12860 | | | `--RPAREN -> ) [1204:96]
12861 | | |--COMMA -> , [1204:97]
12862 | | |--EXPR -> EXPR [1205:22]
12863 | | | `--PLUS -> + [1205:22]
12864 | | | |--STRING_LITERAL -> "52:21: " [1205:12]
12865 | | | `--METHOD_CALL -> ( [1205:39]
12866 | | | |--IDENT -> getCheckMessage [1205:24]
12867 | | | |--ELIST -> ELIST [1205:40]
12868 | | | | |--EXPR -> EXPR [1205:40]
12869 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [1205:40]
12870 | | | | |--COMMA -> , [1205:61]
12871 | | | | |--EXPR -> EXPR [1205:63]
12872 | | | | | `--STRING_LITERAL -> "array initialization" [1205:63]
12873 | | | | |--COMMA -> , [1205:85]
12874 | | | | |--EXPR -> EXPR [1205:87]
12875 | | | | | `--NUM_INT -> 20 [1205:87]
12876 | | | | |--COMMA -> , [1205:89]
12877 | | | | `--EXPR -> EXPR [1206:16]
12878 | | | | `--STRING_LITERAL -> "8, 31, 33" [1206:16]
12879 | | | `--RPAREN -> ) [1206:27]
12880 | | |--COMMA -> , [1206:28]
12881 | | |--EXPR -> EXPR [1207:21]
12882 | | | `--PLUS -> + [1207:21]
12883 | | | |--STRING_LITERAL -> "53:5: " [1207:12]
12884 | | | `--METHOD_CALL -> ( [1207:38]
12885 | | | |--IDENT -> getCheckMessage [1207:23]
12886 | | | |--ELIST -> ELIST [1207:39]
12887 | | | | |--EXPR -> EXPR [1207:39]
12888 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [1207:39]
12889 | | | | |--COMMA -> , [1207:60]
12890 | | | | |--EXPR -> EXPR [1207:62]
12891 | | | | | `--STRING_LITERAL -> "array initialization" [1207:62]
12892 | | | | |--COMMA -> , [1207:84]
12893 | | | | |--EXPR -> EXPR [1208:20]
12894 | | | | | `--NUM_INT -> 4 [1208:20]
12895 | | | | |--COMMA -> , [1208:21]
12896 | | | | `--EXPR -> EXPR [1208:23]
12897 | | | | `--STRING_LITERAL -> "8, 31, 33" [1208:23]
12898 | | | `--RPAREN -> ) [1208:34]
12899 | | |--COMMA -> , [1208:35]
12900 | | |--EXPR -> EXPR [1209:21]
12901 | | | `--PLUS -> + [1209:21]
12902 | | | |--STRING_LITERAL -> "58:7: " [1209:12]
12903 | | | `--METHOD_CALL -> ( [1209:38]
12904 | | | |--IDENT -> getCheckMessage [1209:23]
12905 | | | |--ELIST -> ELIST [1209:39]
12906 | | | | |--EXPR -> EXPR [1209:39]
12907 | | | | | `--IDENT -> MSG_CHILD_ERROR [1209:39]
12908 | | | | |--COMMA -> , [1209:54]
12909 | | | | |--EXPR -> EXPR [1209:56]
12910 | | | | | `--STRING_LITERAL -> "array initialization" [1209:56]
12911 | | | | |--COMMA -> , [1209:78]
12912 | | | | |--EXPR -> EXPR [1209:80]
12913 | | | | | `--NUM_INT -> 6 [1209:80]
12914 | | | | |--COMMA -> , [1209:81]
12915 | | | | `--EXPR -> EXPR [1209:83]
12916 | | | | `--NUM_INT -> 8 [1209:83]
12917 | | | `--RPAREN -> ) [1209:84]
12918 | | |--COMMA -> , [1209:85]
12919 | | |--EXPR -> EXPR [1210:21]
12920 | | | `--PLUS -> + [1210:21]
12921 | | | |--STRING_LITERAL -> "63:3: " [1210:12]
12922 | | | `--METHOD_CALL -> ( [1210:38]
12923 | | | |--IDENT -> getCheckMessage [1210:23]
12924 | | | |--ELIST -> ELIST [1210:39]
12925 | | | | |--EXPR -> EXPR [1210:39]
12926 | | | | | `--IDENT -> MSG_ERROR [1210:39]
12927 | | | | |--COMMA -> , [1210:48]
12928 | | | | |--EXPR -> EXPR [1210:50]
12929 | | | | | `--STRING_LITERAL -> "member def type" [1210:50]
12930 | | | | |--COMMA -> , [1210:67]
12931 | | | | |--EXPR -> EXPR [1210:69]
12932 | | | | | `--NUM_INT -> 2 [1210:69]
12933 | | | | |--COMMA -> , [1210:70]
12934 | | | | `--EXPR -> EXPR [1210:72]
12935 | | | | `--NUM_INT -> 4 [1210:72]
12936 | | | `--RPAREN -> ) [1210:73]
12937 | | |--COMMA -> , [1210:74]
12938 | | |--EXPR -> EXPR [1211:21]
12939 | | | `--PLUS -> + [1211:21]
12940 | | | |--STRING_LITERAL -> "65:7: " [1211:12]
12941 | | | `--METHOD_CALL -> ( [1211:38]
12942 | | | |--IDENT -> getCheckMessage [1211:23]
12943 | | | |--ELIST -> ELIST [1211:39]
12944 | | | | |--EXPR -> EXPR [1211:39]
12945 | | | | | `--IDENT -> MSG_ERROR [1211:39]
12946 | | | | |--COMMA -> , [1211:48]
12947 | | | | |--EXPR -> EXPR [1211:50]
12948 | | | | | `--STRING_LITERAL -> "member def type" [1211:50]
12949 | | | | |--COMMA -> , [1211:67]
12950 | | | | |--EXPR -> EXPR [1211:69]
12951 | | | | | `--NUM_INT -> 6 [1211:69]
12952 | | | | |--COMMA -> , [1211:70]
12953 | | | | `--EXPR -> EXPR [1211:72]
12954 | | | | `--NUM_INT -> 4 [1211:72]
12955 | | | `--RPAREN -> ) [1211:73]
12956 | | |--COMMA -> , [1211:74]
12957 | | |--EXPR -> EXPR [1212:21]
12958 | | | `--PLUS -> + [1212:21]
12959 | | | |--STRING_LITERAL -> "66:3: " [1212:12]
12960 | | | `--METHOD_CALL -> ( [1212:38]
12961 | | | |--IDENT -> getCheckMessage [1212:23]
12962 | | | |--ELIST -> ELIST [1212:39]
12963 | | | | |--EXPR -> EXPR [1212:39]
12964 | | | | | `--IDENT -> MSG_ERROR_MULTI [1212:39]
12965 | | | | |--COMMA -> , [1212:54]
12966 | | | | |--EXPR -> EXPR [1212:56]
12967 | | | | | `--STRING_LITERAL -> "array initialization rcurly" [1212:56]
12968 | | | | |--COMMA -> , [1212:85]
12969 | | | | |--EXPR -> EXPR [1212:87]
12970 | | | | | `--NUM_INT -> 2 [1212:87]
12971 | | | | |--COMMA -> , [1212:88]
12972 | | | | `--EXPR -> EXPR [1212:90]
12973 | | | | `--STRING_LITERAL -> "6, 10" [1212:90]
12974 | | | `--RPAREN -> ) [1212:97]
12975 | | |--COMMA -> , [1212:98]
12976 | | |--EXPR -> EXPR [1213:21]
12977 | | | `--PLUS -> + [1213:21]
12978 | | | |--STRING_LITERAL -> "69:7: " [1213:12]
12979 | | | `--METHOD_CALL -> ( [1213:38]
12980 | | | |--IDENT -> getCheckMessage [1213:23]
12981 | | | |--ELIST -> ELIST [1213:39]
12982 | | | | |--EXPR -> EXPR [1213:39]
12983 | | | | | `--IDENT -> MSG_CHILD_ERROR [1213:39]
12984 | | | | |--COMMA -> , [1213:54]
12985 | | | | |--EXPR -> EXPR [1213:56]
12986 | | | | | `--STRING_LITERAL -> "array initialization" [1213:56]
12987 | | | | |--COMMA -> , [1213:78]
12988 | | | | |--EXPR -> EXPR [1213:80]
12989 | | | | | `--NUM_INT -> 6 [1213:80]
12990 | | | | |--COMMA -> , [1213:81]
12991 | | | | `--EXPR -> EXPR [1213:83]
12992 | | | | `--NUM_INT -> 8 [1213:83]
12993 | | | `--RPAREN -> ) [1213:84]
12994 | | |--COMMA -> , [1213:85]
12995 | | |--EXPR -> EXPR [1214:22]
12996 | | | `--PLUS -> + [1214:22]
12997 | | | |--STRING_LITERAL -> "76:11: " [1214:12]
12998 | | | `--METHOD_CALL -> ( [1214:39]
12999 | | | |--IDENT -> getCheckMessage [1214:24]
13000 | | | |--ELIST -> ELIST [1214:40]
13001 | | | | |--EXPR -> EXPR [1214:40]
13002 | | | | | `--IDENT -> MSG_CHILD_ERROR [1214:40]
13003 | | | | |--COMMA -> , [1214:55]
13004 | | | | |--EXPR -> EXPR [1214:57]
13005 | | | | | `--STRING_LITERAL -> "array initialization" [1214:57]
13006 | | | | |--COMMA -> , [1214:79]
13007 | | | | |--EXPR -> EXPR [1214:81]
13008 | | | | | `--NUM_INT -> 10 [1214:81]
13009 | | | | |--COMMA -> , [1214:83]
13010 | | | | `--EXPR -> EXPR [1214:85]
13011 | | | | `--NUM_INT -> 12 [1214:85]
13012 | | | `--RPAREN -> ) [1214:87]
13013 | | |--COMMA -> , [1214:88]
13014 | | |--EXPR -> EXPR [1215:21]
13015 | | | `--PLUS -> + [1215:21]
13016 | | | |--STRING_LITERAL -> "89:9: " [1215:12]
13017 | | | `--METHOD_CALL -> ( [1215:38]
13018 | | | |--IDENT -> getCheckMessage [1215:23]
13019 | | | |--ELIST -> ELIST [1215:39]
13020 | | | | |--EXPR -> EXPR [1215:39]
13021 | | | | | `--IDENT -> MSG_ERROR [1215:39]
13022 | | | | |--COMMA -> , [1215:48]
13023 | | | | |--EXPR -> EXPR [1215:50]
13024 | | | | | `--STRING_LITERAL -> "1" [1215:50]
13025 | | | | |--COMMA -> , [1215:53]
13026 | | | | |--EXPR -> EXPR [1215:55]
13027 | | | | | `--NUM_INT -> 8 [1215:55]
13028 | | | | |--COMMA -> , [1215:56]
13029 | | | | `--EXPR -> EXPR [1215:58]
13030 | | | | `--NUM_INT -> 12 [1215:58]
13031 | | | `--RPAREN -> ) [1215:60]
13032 | | |--COMMA -> , [1215:61]
13033 | | |--EXPR -> EXPR [1216:23]
13034 | | | `--PLUS -> + [1216:23]
13035 | | | |--STRING_LITERAL -> "100:11: " [1216:12]
13036 | | | `--METHOD_CALL -> ( [1216:40]
13037 | | | |--IDENT -> getCheckMessage [1216:25]
13038 | | | |--ELIST -> ELIST [1216:41]
13039 | | | | |--EXPR -> EXPR [1216:41]
13040 | | | | | `--IDENT -> MSG_CHILD_ERROR [1216:41]
13041 | | | | |--COMMA -> , [1216:56]
13042 | | | | |--EXPR -> EXPR [1216:58]
13043 | | | | | `--STRING_LITERAL -> "array initialization" [1216:58]
13044 | | | | |--COMMA -> , [1216:80]
13045 | | | | |--EXPR -> EXPR [1216:82]
13046 | | | | | `--NUM_INT -> 10 [1216:82]
13047 | | | | |--COMMA -> , [1216:84]
13048 | | | | `--EXPR -> EXPR [1216:86]
13049 | | | | `--NUM_INT -> 12 [1216:86]
13050 | | | `--RPAREN -> ) [1216:88]
13051 | | |--COMMA -> , [1216:89]
13052 | | |--EXPR -> EXPR [1217:23]
13053 | | | `--PLUS -> + [1217:23]
13054 | | | |--STRING_LITERAL -> "101:15: " [1217:12]
13055 | | | `--METHOD_CALL -> ( [1217:40]
13056 | | | |--IDENT -> getCheckMessage [1217:25]
13057 | | | |--ELIST -> ELIST [1217:41]
13058 | | | | |--EXPR -> EXPR [1217:41]
13059 | | | | | `--IDENT -> MSG_CHILD_ERROR [1217:41]
13060 | | | | |--COMMA -> , [1217:56]
13061 | | | | |--EXPR -> EXPR [1217:58]
13062 | | | | | `--STRING_LITERAL -> "array initialization" [1217:58]
13063 | | | | |--COMMA -> , [1217:80]
13064 | | | | |--EXPR -> EXPR [1217:82]
13065 | | | | | `--NUM_INT -> 14 [1217:82]
13066 | | | | |--COMMA -> , [1217:84]
13067 | | | | `--EXPR -> EXPR [1217:86]
13068 | | | | `--NUM_INT -> 12 [1217:86]
13069 | | | `--RPAREN -> ) [1217:88]
13070 | | |--COMMA -> , [1217:89]
13071 | | |--EXPR -> EXPR [1218:23]
13072 | | | `--PLUS -> + [1218:23]
13073 | | | |--STRING_LITERAL -> "104:11: " [1218:12]
13074 | | | `--METHOD_CALL -> ( [1218:40]
13075 | | | |--IDENT -> getCheckMessage [1218:25]
13076 | | | |--ELIST -> ELIST [1218:41]
13077 | | | | |--EXPR -> EXPR [1218:41]
13078 | | | | | `--IDENT -> MSG_CHILD_ERROR [1218:41]
13079 | | | | |--COMMA -> , [1218:56]
13080 | | | | |--EXPR -> EXPR [1218:58]
13081 | | | | | `--STRING_LITERAL -> "array initialization" [1218:58]
13082 | | | | |--COMMA -> , [1218:80]
13083 | | | | |--EXPR -> EXPR [1218:82]
13084 | | | | | `--NUM_INT -> 10 [1218:82]
13085 | | | | |--COMMA -> , [1218:84]
13086 | | | | `--EXPR -> EXPR [1218:86]
13087 | | | | `--NUM_INT -> 12 [1218:86]
13088 | | | `--RPAREN -> ) [1218:88]
13089 | | |--COMMA -> , [1218:89]
13090 | | |--EXPR -> EXPR [1219:23]
13091 | | | `--PLUS -> + [1219:23]
13092 | | | |--STRING_LITERAL -> "105:15: " [1219:12]
13093 | | | `--METHOD_CALL -> ( [1219:40]
13094 | | | |--IDENT -> getCheckMessage [1219:25]
13095 | | | |--ELIST -> ELIST [1219:41]
13096 | | | | |--EXPR -> EXPR [1219:41]
13097 | | | | | `--IDENT -> MSG_CHILD_ERROR [1219:41]
13098 | | | | |--COMMA -> , [1219:56]
13099 | | | | |--EXPR -> EXPR [1219:58]
13100 | | | | | `--STRING_LITERAL -> "array initialization" [1219:58]
13101 | | | | |--COMMA -> , [1219:80]
13102 | | | | |--EXPR -> EXPR [1219:82]
13103 | | | | | `--NUM_INT -> 14 [1219:82]
13104 | | | | |--COMMA -> , [1219:84]
13105 | | | | `--EXPR -> EXPR [1219:86]
13106 | | | | `--NUM_INT -> 12 [1219:86]
13107 | | | `--RPAREN -> ) [1219:88]
13108 | | |--COMMA -> , [1219:89]
13109 | | |--EXPR -> EXPR [1220:22]
13110 | | | `--PLUS -> + [1220:22]
13111 | | | |--STRING_LITERAL -> "106:7: " [1220:12]
13112 | | | `--METHOD_CALL -> ( [1220:39]
13113 | | | |--IDENT -> getCheckMessage [1220:24]
13114 | | | |--ELIST -> ELIST [1220:40]
13115 | | | | |--EXPR -> EXPR [1220:40]
13116 | | | | | `--IDENT -> MSG_ERROR_MULTI [1220:40]
13117 | | | | |--COMMA -> , [1220:55]
13118 | | | | |--EXPR -> EXPR [1220:57]
13119 | | | | | `--STRING_LITERAL -> "array initialization rcurly" [1220:57]
13120 | | | | |--COMMA -> , [1220:86]
13121 | | | | |--EXPR -> EXPR [1220:88]
13122 | | | | | `--NUM_INT -> 6 [1220:88]
13123 | | | | |--COMMA -> , [1220:89]
13124 | | | | `--EXPR -> EXPR [1220:91]
13125 | | | | `--STRING_LITERAL -> "8, 12" [1220:91]
13126 | | | `--RPAREN -> ) [1220:98]
13127 | | |--COMMA -> , [1220:99]
13128 | | |--EXPR -> EXPR [1221:22]
13129 | | | `--PLUS -> + [1221:22]
13130 | | | |--STRING_LITERAL -> "109:7: " [1221:12]
13131 | | | `--METHOD_CALL -> ( [1221:39]
13132 | | | |--IDENT -> getCheckMessage [1221:24]
13133 | | | |--ELIST -> ELIST [1221:40]
13134 | | | | |--EXPR -> EXPR [1221:40]
13135 | | | | | `--IDENT -> MSG_ERROR_MULTI [1221:40]
13136 | | | | |--COMMA -> , [1221:55]
13137 | | | | |--EXPR -> EXPR [1221:57]
13138 | | | | | `--STRING_LITERAL -> "array initialization lcurly" [1221:57]
13139 | | | | |--COMMA -> , [1221:86]
13140 | | | | |--EXPR -> EXPR [1221:88]
13141 | | | | | `--NUM_INT -> 6 [1221:88]
13142 | | | | |--COMMA -> , [1221:89]
13143 | | | | `--EXPR -> EXPR [1221:91]
13144 | | | | `--STRING_LITERAL -> "8, 12" [1221:91]
13145 | | | `--RPAREN -> ) [1221:98]
13146 | | |--COMMA -> , [1221:99]
13147 | | |--EXPR -> EXPR [1222:23]
13148 | | | `--PLUS -> + [1222:23]
13149 | | | |--STRING_LITERAL -> "110:15: " [1222:12]
13150 | | | `--METHOD_CALL -> ( [1222:40]
13151 | | | |--IDENT -> getCheckMessage [1222:25]
13152 | | | |--ELIST -> ELIST [1222:41]
13153 | | | | |--EXPR -> EXPR [1222:41]
13154 | | | | | `--IDENT -> MSG_CHILD_ERROR [1222:41]
13155 | | | | |--COMMA -> , [1222:56]
13156 | | | | |--EXPR -> EXPR [1222:58]
13157 | | | | | `--STRING_LITERAL -> "array initialization" [1222:58]
13158 | | | | |--COMMA -> , [1222:80]
13159 | | | | |--EXPR -> EXPR [1222:82]
13160 | | | | | `--NUM_INT -> 14 [1222:82]
13161 | | | | |--COMMA -> , [1222:84]
13162 | | | | `--EXPR -> EXPR [1222:86]
13163 | | | | `--NUM_INT -> 12 [1222:86]
13164 | | | `--RPAREN -> ) [1222:88]
13165 | | |--COMMA -> , [1222:89]
13166 | | |--EXPR -> EXPR [1223:23]
13167 | | | `--PLUS -> + [1223:23]
13168 | | | |--STRING_LITERAL -> "111:11: " [1223:12]
13169 | | | `--METHOD_CALL -> ( [1223:40]
13170 | | | |--IDENT -> getCheckMessage [1223:25]
13171 | | | |--ELIST -> ELIST [1223:41]
13172 | | | | |--EXPR -> EXPR [1223:41]
13173 | | | | | `--IDENT -> MSG_CHILD_ERROR [1223:41]
13174 | | | | |--COMMA -> , [1223:56]
13175 | | | | |--EXPR -> EXPR [1223:58]
13176 | | | | | `--STRING_LITERAL -> "array initialization" [1223:58]
13177 | | | | |--COMMA -> , [1223:80]
13178 | | | | |--EXPR -> EXPR [1223:82]
13179 | | | | | `--NUM_INT -> 10 [1223:82]
13180 | | | | |--COMMA -> , [1223:84]
13181 | | | | `--EXPR -> EXPR [1223:86]
13182 | | | | `--NUM_INT -> 12 [1223:86]
13183 | | | `--RPAREN -> ) [1223:88]
13184 | | |--COMMA -> , [1223:89]
13185 | | |--EXPR -> EXPR [1224:22]
13186 | | | `--PLUS -> + [1224:22]
13187 | | | |--STRING_LITERAL -> "112:7: " [1224:12]
13188 | | | `--METHOD_CALL -> ( [1224:39]
13189 | | | |--IDENT -> getCheckMessage [1224:24]
13190 | | | |--ELIST -> ELIST [1224:40]
13191 | | | | |--EXPR -> EXPR [1224:40]
13192 | | | | | `--IDENT -> MSG_ERROR_MULTI [1224:40]
13193 | | | | |--COMMA -> , [1224:55]
13194 | | | | |--EXPR -> EXPR [1224:57]
13195 | | | | | `--STRING_LITERAL -> "array initialization rcurly" [1224:57]
13196 | | | | |--COMMA -> , [1224:86]
13197 | | | | |--EXPR -> EXPR [1224:88]
13198 | | | | | `--NUM_INT -> 6 [1224:88]
13199 | | | | |--COMMA -> , [1224:89]
13200 | | | | `--EXPR -> EXPR [1224:91]
13201 | | | | `--STRING_LITERAL -> "8, 12" [1224:91]
13202 | | | `--RPAREN -> ) [1224:98]
13203 | | |--COMMA -> , [1224:99]
13204 | | |--EXPR -> EXPR [1226:23]
13205 | | | `--PLUS -> + [1226:23]
13206 | | | |--SINGLE_LINE_COMMENT -> // [1225:12]
13207 | | | | `--COMMENT_CONTENT -> following are tests for annotation array initialisation\n [1225:14]
13208 | | | |--STRING_LITERAL -> "120:13: " [1226:12]
13209 | | | `--METHOD_CALL -> ( [1226:40]
13210 | | | |--IDENT -> getCheckMessage [1226:25]
13211 | | | |--ELIST -> ELIST [1226:41]
13212 | | | | |--EXPR -> EXPR [1226:41]
13213 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [1226:41]
13214 | | | | |--COMMA -> , [1226:62]
13215 | | | | |--EXPR -> EXPR [1226:64]
13216 | | | | | `--STRING_LITERAL -> "annotation array initialization" [1226:64]
13217 | | | | |--COMMA -> , [1226:97]
13218 | | | | |--EXPR -> EXPR [1227:16]
13219 | | | | | `--NUM_INT -> 12 [1227:16]
13220 | | | | |--COMMA -> , [1227:18]
13221 | | | | `--EXPR -> EXPR [1227:20]
13222 | | | | `--STRING_LITERAL -> "16, 46, 48" [1227:20]
13223 | | | `--RPAREN -> ) [1227:32]
13224 | | |--COMMA -> , [1227:33]
13225 | | |--EXPR -> EXPR [1228:23]
13226 | | | `--PLUS -> + [1228:23]
13227 | | | |--STRING_LITERAL -> "124:15: " [1228:12]
13228 | | | `--METHOD_CALL -> ( [1228:40]
13229 | | | |--IDENT -> getCheckMessage [1228:25]
13230 | | | |--ELIST -> ELIST [1228:41]
13231 | | | | |--EXPR -> EXPR [1228:41]
13232 | | | | | `--IDENT -> MSG_CHILD_ERROR [1228:41]
13233 | | | | |--COMMA -> , [1228:56]
13234 | | | | |--EXPR -> EXPR [1228:58]
13235 | | | | | `--STRING_LITERAL -> "annotation array initialization" [1228:58]
13236 | | | | |--COMMA -> , [1228:91]
13237 | | | | |--EXPR -> EXPR [1229:16]
13238 | | | | | `--NUM_INT -> 14 [1229:16]
13239 | | | | |--COMMA -> , [1229:18]
13240 | | | | `--EXPR -> EXPR [1229:20]
13241 | | | | `--NUM_INT -> 12 [1229:20]
13242 | | | `--RPAREN -> ) [1229:22]
13243 | | |--COMMA -> , [1229:23]
13244 | | |--EXPR -> EXPR [1230:23]
13245 | | | `--PLUS -> + [1230:23]
13246 | | | |--STRING_LITERAL -> "128:15: " [1230:12]
13247 | | | `--METHOD_CALL -> ( [1230:40]
13248 | | | |--IDENT -> getCheckMessage [1230:25]
13249 | | | |--ELIST -> ELIST [1230:41]
13250 | | | | |--EXPR -> EXPR [1230:41]
13251 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [1230:41]
13252 | | | | |--COMMA -> , [1230:62]
13253 | | | | |--EXPR -> EXPR [1230:64]
13254 | | | | | `--STRING_LITERAL -> "annotation array initialization" [1230:64]
13255 | | | | |--COMMA -> , [1230:97]
13256 | | | | |--EXPR -> EXPR [1231:16]
13257 | | | | | `--NUM_INT -> 14 [1231:16]
13258 | | | | |--COMMA -> , [1231:18]
13259 | | | | `--EXPR -> EXPR [1231:20]
13260 | | | | `--STRING_LITERAL -> "16, 28, 30" [1231:20]
13261 | | | `--RPAREN -> ) [1231:32]
13262 | | |--COMMA -> , [1231:33]
13263 | | |--EXPR -> EXPR [1232:22]
13264 | | | `--PLUS -> + [1232:22]
13265 | | | |--STRING_LITERAL -> "129:9: " [1232:12]
13266 | | | `--METHOD_CALL -> ( [1232:39]
13267 | | | |--IDENT -> getCheckMessage [1232:24]
13268 | | | |--ELIST -> ELIST [1232:40]
13269 | | | | |--EXPR -> EXPR [1232:40]
13270 | | | | | `--IDENT -> MSG_ERROR_MULTI [1232:40]
13271 | | | | |--COMMA -> , [1232:55]
13272 | | | | |--EXPR -> EXPR [1232:57]
13273 | | | | | `--STRING_LITERAL -> "annotation array initialization rcurly" [1232:57]
13274 | | | | |--COMMA -> , [1232:97]
13275 | | | | |--EXPR -> EXPR [1233:16]
13276 | | | | | `--NUM_INT -> 8 [1233:16]
13277 | | | | |--COMMA -> , [1233:17]
13278 | | | | `--EXPR -> EXPR [1233:19]
13279 | | | | `--STRING_LITERAL -> "12, 16" [1233:19]
13280 | | | `--RPAREN -> ) [1233:27]
13281 | | |--COMMA -> , [1233:28]
13282 | | |--EXPR -> EXPR [1234:23]
13283 | | | `--PLUS -> + [1234:23]
13284 | | | |--STRING_LITERAL -> "131:13: " [1234:12]
13285 | | | `--METHOD_CALL -> ( [1234:40]
13286 | | | |--IDENT -> getCheckMessage [1234:25]
13287 | | | |--ELIST -> ELIST [1234:41]
13288 | | | | |--EXPR -> EXPR [1234:41]
13289 | | | | | `--IDENT -> MSG_CHILD_ERROR [1234:41]
13290 | | | | |--COMMA -> , [1234:56]
13291 | | | | |--EXPR -> EXPR [1234:58]
13292 | | | | | `--STRING_LITERAL -> "annotation array initialization" [1234:58]
13293 | | | | |--COMMA -> , [1234:91]
13294 | | | | |--EXPR -> EXPR [1235:16]
13295 | | | | | `--NUM_INT -> 12 [1235:16]
13296 | | | | |--COMMA -> , [1235:18]
13297 | | | | `--EXPR -> EXPR [1235:20]
13298 | | | | `--NUM_INT -> 16 [1235:20]
13299 | | | `--RPAREN -> ) [1235:22]
13300 | | |--COMMA -> , [1235:23]
13301 | | `--RCURLY -> } [1236:8]
13302 | |--SEMI -> ; [1236:9]
13303 | |--EXPR -> EXPR [1239:14]
13304 | | `--METHOD_CALL -> ( [1239:14]
13305 | | |--SINGLE_LINE_COMMENT -> // [1238:8]
13306 | | | `--COMMENT_CONTENT -> Test input for this test case is not checked due to issue #693.\n [1238:10]
13307 | | |--IDENT -> verify [1239:8]
13308 | | |--ELIST -> ELIST [1239:15]
13309 | | | |--EXPR -> EXPR [1239:15]
13310 | | | | `--IDENT -> checkConfig [1239:15]
13311 | | | |--COMMA -> , [1239:26]
13312 | | | |--EXPR -> EXPR [1239:28]
13313 | | | | `--IDENT -> fileName [1239:28]
13314 | | | |--COMMA -> , [1239:36]
13315 | | | `--EXPR -> EXPR [1239:38]
13316 | | | `--IDENT -> expected [1239:38]
13317 | | `--RPAREN -> ) [1239:46]
13318 | |--SEMI -> ; [1239:47]
13319 | `--RCURLY -> } [1240:4]
13320 |--METHOD_DEF -> METHOD_DEF [1242:4]
13321 | |--MODIFIERS -> MODIFIERS [1242:4]
13322 | | |--ANNOTATION -> ANNOTATION [1242:4]
13323 | | | |--AT -> @ [1242:4]
13324 | | | `--IDENT -> Test [1242:5]
13325 | | `--LITERAL_PUBLIC -> public [1243:4]
13326 | |--TYPE -> TYPE [1243:11]
13327 | | `--LITERAL_VOID -> void [1243:11]
13328 | |--IDENT -> testChainedMethodCalling [1243:16]
13329 | |--LPAREN -> ( [1243:40]
13330 | |--PARAMETERS -> PARAMETERS [1243:41]
13331 | |--RPAREN -> ) [1243:41]
13332 | |--LITERAL_THROWS -> throws [1243:43]
13333 | | `--IDENT -> Exception [1243:50]
13334 | `--SLIST -> { [1243:60]
13335 | |--VARIABLE_DEF -> VARIABLE_DEF [1244:8]
13336 | | |--MODIFIERS -> MODIFIERS [1244:8]
13337 | | | `--FINAL -> final [1244:8]
13338 | | |--TYPE -> TYPE [1244:14]
13339 | | | `--IDENT -> DefaultConfiguration [1244:14]
13340 | | |--IDENT -> checkConfig [1244:35]
13341 | | `--ASSIGN -> = [1244:47]
13342 | | `--EXPR -> EXPR [1244:67]
13343 | | `--METHOD_CALL -> ( [1244:67]
13344 | | |--IDENT -> createModuleConfig [1244:49]
13345 | | |--ELIST -> ELIST [1244:84]
13346 | | | `--EXPR -> EXPR [1244:84]
13347 | | | `--DOT -> . [1244:84]
13348 | | | |--IDENT -> IndentationCheck [1244:68]
13349 | | | `--LITERAL_CLASS -> class [1244:85]
13350 | | `--RPAREN -> ) [1244:90]
13351 | |--SEMI -> ; [1244:91]
13352 | |--EXPR -> EXPR [1246:32]
13353 | | `--METHOD_CALL -> ( [1246:32]
13354 | | |--DOT -> . [1246:19]
13355 | | | |--IDENT -> checkConfig [1246:8]
13356 | | | `--IDENT -> addAttribute [1246:20]
13357 | | |--ELIST -> ELIST [1246:33]
13358 | | | |--EXPR -> EXPR [1246:33]
13359 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1246:33]
13360 | | | |--COMMA -> , [1246:50]
13361 | | | `--EXPR -> EXPR [1246:52]
13362 | | | `--STRING_LITERAL -> "2" [1246:52]
13363 | | `--RPAREN -> ) [1246:55]
13364 | |--SEMI -> ; [1246:56]
13365 | |--EXPR -> EXPR [1247:32]
13366 | | `--METHOD_CALL -> ( [1247:32]
13367 | | |--DOT -> . [1247:19]
13368 | | | |--IDENT -> checkConfig [1247:8]
13369 | | | `--IDENT -> addAttribute [1247:20]
13370 | | |--ELIST -> ELIST [1247:33]
13371 | | | |--EXPR -> EXPR [1247:33]
13372 | | | | `--STRING_LITERAL -> "basicOffset" [1247:33]
13373 | | | |--COMMA -> , [1247:46]
13374 | | | `--EXPR -> EXPR [1247:48]
13375 | | | `--STRING_LITERAL -> "2" [1247:48]
13376 | | `--RPAREN -> ) [1247:51]
13377 | |--SEMI -> ; [1247:52]
13378 | |--EXPR -> EXPR [1248:32]
13379 | | `--METHOD_CALL -> ( [1248:32]
13380 | | |--DOT -> . [1248:19]
13381 | | | |--IDENT -> checkConfig [1248:8]
13382 | | | `--IDENT -> addAttribute [1248:20]
13383 | | |--ELIST -> ELIST [1248:33]
13384 | | | |--EXPR -> EXPR [1248:33]
13385 | | | | `--STRING_LITERAL -> "braceAdjustment" [1248:33]
13386 | | | |--COMMA -> , [1248:50]
13387 | | | `--EXPR -> EXPR [1248:52]
13388 | | | `--STRING_LITERAL -> "2" [1248:52]
13389 | | `--RPAREN -> ) [1248:55]
13390 | |--SEMI -> ; [1248:56]
13391 | |--EXPR -> EXPR [1249:32]
13392 | | `--METHOD_CALL -> ( [1249:32]
13393 | | |--DOT -> . [1249:19]
13394 | | | |--IDENT -> checkConfig [1249:8]
13395 | | | `--IDENT -> addAttribute [1249:20]
13396 | | |--ELIST -> ELIST [1249:33]
13397 | | | |--EXPR -> EXPR [1249:33]
13398 | | | | `--STRING_LITERAL -> "caseIndent" [1249:33]
13399 | | | |--COMMA -> , [1249:45]
13400 | | | `--EXPR -> EXPR [1249:47]
13401 | | | `--STRING_LITERAL -> "2" [1249:47]
13402 | | `--RPAREN -> ) [1249:50]
13403 | |--SEMI -> ; [1249:51]
13404 | |--EXPR -> EXPR [1250:32]
13405 | | `--METHOD_CALL -> ( [1250:32]
13406 | | |--DOT -> . [1250:19]
13407 | | | |--IDENT -> checkConfig [1250:8]
13408 | | | `--IDENT -> addAttribute [1250:20]
13409 | | |--ELIST -> ELIST [1250:33]
13410 | | | |--EXPR -> EXPR [1250:33]
13411 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1250:33]
13412 | | | |--COMMA -> , [1250:55]
13413 | | | `--EXPR -> EXPR [1250:57]
13414 | | | `--STRING_LITERAL -> "false" [1250:57]
13415 | | `--RPAREN -> ) [1250:64]
13416 | |--SEMI -> ; [1250:65]
13417 | |--EXPR -> EXPR [1251:32]
13418 | | `--METHOD_CALL -> ( [1251:32]
13419 | | |--DOT -> . [1251:19]
13420 | | | |--IDENT -> checkConfig [1251:8]
13421 | | | `--IDENT -> addAttribute [1251:20]
13422 | | |--ELIST -> ELIST [1251:33]
13423 | | | |--EXPR -> EXPR [1251:33]
13424 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1251:33]
13425 | | | |--COMMA -> , [1251:58]
13426 | | | `--EXPR -> EXPR [1251:60]
13427 | | | `--STRING_LITERAL -> "4" [1251:60]
13428 | | `--RPAREN -> ) [1251:63]
13429 | |--SEMI -> ; [1251:64]
13430 | |--EXPR -> EXPR [1252:32]
13431 | | `--METHOD_CALL -> ( [1252:32]
13432 | | |--DOT -> . [1252:19]
13433 | | | |--IDENT -> checkConfig [1252:8]
13434 | | | `--IDENT -> addAttribute [1252:20]
13435 | | |--ELIST -> ELIST [1252:33]
13436 | | | |--EXPR -> EXPR [1252:33]
13437 | | | | `--STRING_LITERAL -> "tabWidth" [1252:33]
13438 | | | |--COMMA -> , [1252:43]
13439 | | | `--EXPR -> EXPR [1252:45]
13440 | | | `--STRING_LITERAL -> "4" [1252:45]
13441 | | `--RPAREN -> ) [1252:48]
13442 | |--SEMI -> ; [1252:49]
13443 | |--EXPR -> EXPR [1253:32]
13444 | | `--METHOD_CALL -> ( [1253:32]
13445 | | |--DOT -> . [1253:19]
13446 | | | |--IDENT -> checkConfig [1253:8]
13447 | | | `--IDENT -> addAttribute [1253:20]
13448 | | |--ELIST -> ELIST [1253:33]
13449 | | | |--EXPR -> EXPR [1253:33]
13450 | | | | `--STRING_LITERAL -> "throwsIndent" [1253:33]
13451 | | | |--COMMA -> , [1253:47]
13452 | | | `--EXPR -> EXPR [1253:49]
13453 | | | `--STRING_LITERAL -> "4" [1253:49]
13454 | | `--RPAREN -> ) [1253:52]
13455 | |--SEMI -> ; [1253:53]
13456 | |--VARIABLE_DEF -> VARIABLE_DEF [1254:8]
13457 | | |--MODIFIERS -> MODIFIERS [1254:8]
13458 | | | `--FINAL -> final [1254:8]
13459 | | |--TYPE -> TYPE [1254:14]
13460 | | | `--IDENT -> String [1254:14]
13461 | | |--IDENT -> fileName [1254:21]
13462 | | `--ASSIGN -> = [1254:30]
13463 | | `--EXPR -> EXPR [1254:39]
13464 | | `--METHOD_CALL -> ( [1254:39]
13465 | | |--IDENT -> getPath [1254:32]
13466 | | |--ELIST -> ELIST [1254:40]
13467 | | | `--EXPR -> EXPR [1254:40]
13468 | | | `--STRING_LITERAL -> "InputIndentationChainedMethodCalls.java" [1254:40]
13469 | | `--RPAREN -> ) [1254:81]
13470 | |--SEMI -> ; [1254:82]
13471 | |--VARIABLE_DEF -> VARIABLE_DEF [1255:8]
13472 | | |--MODIFIERS -> MODIFIERS [1255:8]
13473 | | | `--FINAL -> final [1255:8]
13474 | | |--TYPE -> TYPE [1255:20]
13475 | | | `--ARRAY_DECLARATOR -> [ [1255:20]
13476 | | | |--IDENT -> String [1255:14]
13477 | | | `--RBRACK -> ] [1255:21]
13478 | | |--IDENT -> expected [1255:23]
13479 | | `--ASSIGN -> = [1255:32]
13480 | | `--ARRAY_INIT -> { [1255:34]
13481 | | |--EXPR -> EXPR [1256:21]
13482 | | | `--PLUS -> + [1256:21]
13483 | | | |--STRING_LITERAL -> "32:5: " [1256:12]
13484 | | | `--METHOD_CALL -> ( [1256:38]
13485 | | | |--IDENT -> getCheckMessage [1256:23]
13486 | | | |--ELIST -> ELIST [1256:55]
13487 | | | | |--EXPR -> EXPR [1256:55]
13488 | | | | | `--DOT -> . [1256:55]
13489 | | | | | |--IDENT -> IndentationCheck [1256:39]
13490 | | | | | `--LITERAL_CLASS -> class [1256:56]
13491 | | | | |--COMMA -> , [1256:61]
13492 | | | | |--EXPR -> EXPR [1257:16]
13493 | | | | | `--IDENT -> MSG_CHILD_ERROR [1257:16]
13494 | | | | |--COMMA -> , [1257:31]
13495 | | | | |--EXPR -> EXPR [1257:33]
13496 | | | | | `--STRING_LITERAL -> "method call" [1257:33]
13497 | | | | |--COMMA -> , [1257:46]
13498 | | | | |--EXPR -> EXPR [1257:48]
13499 | | | | | `--NUM_INT -> 4 [1257:48]
13500 | | | | |--COMMA -> , [1257:49]
13501 | | | | `--EXPR -> EXPR [1257:51]
13502 | | | | `--NUM_INT -> 8 [1257:51]
13503 | | | `--RPAREN -> ) [1257:52]
13504 | | |--COMMA -> , [1257:53]
13505 | | |--EXPR -> EXPR [1258:21]
13506 | | | `--PLUS -> + [1258:21]
13507 | | | |--STRING_LITERAL -> "37:5: " [1258:12]
13508 | | | `--METHOD_CALL -> ( [1258:38]
13509 | | | |--IDENT -> getCheckMessage [1258:23]
13510 | | | |--ELIST -> ELIST [1258:55]
13511 | | | | |--EXPR -> EXPR [1258:55]
13512 | | | | | `--DOT -> . [1258:55]
13513 | | | | | |--IDENT -> IndentationCheck [1258:39]
13514 | | | | | `--LITERAL_CLASS -> class [1258:56]
13515 | | | | |--COMMA -> , [1258:61]
13516 | | | | |--EXPR -> EXPR [1258:63]
13517 | | | | | `--IDENT -> MSG_ERROR [1258:63]
13518 | | | | |--COMMA -> , [1258:72]
13519 | | | | |--EXPR -> EXPR [1258:74]
13520 | | | | | `--STRING_LITERAL -> "." [1258:74]
13521 | | | | |--COMMA -> , [1258:77]
13522 | | | | |--EXPR -> EXPR [1258:79]
13523 | | | | | `--NUM_INT -> 4 [1258:79]
13524 | | | | |--COMMA -> , [1258:80]
13525 | | | | `--EXPR -> EXPR [1258:82]
13526 | | | | `--NUM_INT -> 8 [1258:82]
13527 | | | `--RPAREN -> ) [1258:83]
13528 | | |--COMMA -> , [1258:84]
13529 | | |--EXPR -> EXPR [1259:21]
13530 | | | `--PLUS -> + [1259:21]
13531 | | | |--STRING_LITERAL -> "38:5: " [1259:12]
13532 | | | `--METHOD_CALL -> ( [1259:38]
13533 | | | |--IDENT -> getCheckMessage [1259:23]
13534 | | | |--ELIST -> ELIST [1259:55]
13535 | | | | |--EXPR -> EXPR [1259:55]
13536 | | | | | `--DOT -> . [1259:55]
13537 | | | | | |--IDENT -> IndentationCheck [1259:39]
13538 | | | | | `--LITERAL_CLASS -> class [1259:56]
13539 | | | | |--COMMA -> , [1259:61]
13540 | | | | |--EXPR -> EXPR [1259:63]
13541 | | | | | `--IDENT -> MSG_ERROR [1259:63]
13542 | | | | |--COMMA -> , [1259:72]
13543 | | | | |--EXPR -> EXPR [1259:74]
13544 | | | | | `--STRING_LITERAL -> "." [1259:74]
13545 | | | | |--COMMA -> , [1259:77]
13546 | | | | |--EXPR -> EXPR [1259:79]
13547 | | | | | `--NUM_INT -> 4 [1259:79]
13548 | | | | |--COMMA -> , [1259:80]
13549 | | | | `--EXPR -> EXPR [1259:82]
13550 | | | | `--NUM_INT -> 8 [1259:82]
13551 | | | `--RPAREN -> ) [1259:83]
13552 | | |--COMMA -> , [1259:84]
13553 | | |--EXPR -> EXPR [1260:21]
13554 | | | `--PLUS -> + [1260:21]
13555 | | | |--STRING_LITERAL -> "41:5: " [1260:12]
13556 | | | `--METHOD_CALL -> ( [1260:38]
13557 | | | |--IDENT -> getCheckMessage [1260:23]
13558 | | | |--ELIST -> ELIST [1260:55]
13559 | | | | |--EXPR -> EXPR [1260:55]
13560 | | | | | `--DOT -> . [1260:55]
13561 | | | | | |--IDENT -> IndentationCheck [1260:39]
13562 | | | | | `--LITERAL_CLASS -> class [1260:56]
13563 | | | | |--COMMA -> , [1260:61]
13564 | | | | |--EXPR -> EXPR [1260:63]
13565 | | | | | `--IDENT -> MSG_ERROR [1260:63]
13566 | | | | |--COMMA -> , [1260:72]
13567 | | | | |--EXPR -> EXPR [1260:74]
13568 | | | | | `--STRING_LITERAL -> "new" [1260:74]
13569 | | | | |--COMMA -> , [1260:79]
13570 | | | | |--EXPR -> EXPR [1260:81]
13571 | | | | | `--NUM_INT -> 4 [1260:81]
13572 | | | | |--COMMA -> , [1260:82]
13573 | | | | `--EXPR -> EXPR [1260:84]
13574 | | | | `--NUM_INT -> 8 [1260:84]
13575 | | | `--RPAREN -> ) [1260:85]
13576 | | |--COMMA -> , [1260:86]
13577 | | `--RCURLY -> } [1261:8]
13578 | |--SEMI -> ; [1261:9]
13579 | |--EXPR -> EXPR [1262:19]
13580 | | `--METHOD_CALL -> ( [1262:19]
13581 | | |--IDENT -> verifyWarns [1262:8]
13582 | | |--ELIST -> ELIST [1262:20]
13583 | | | |--EXPR -> EXPR [1262:20]
13584 | | | | `--IDENT -> checkConfig [1262:20]
13585 | | | |--COMMA -> , [1262:31]
13586 | | | |--EXPR -> EXPR [1262:33]
13587 | | | | `--IDENT -> fileName [1262:33]
13588 | | | |--COMMA -> , [1262:41]
13589 | | | `--EXPR -> EXPR [1262:43]
13590 | | | `--IDENT -> expected [1262:43]
13591 | | `--RPAREN -> ) [1262:51]
13592 | |--SEMI -> ; [1262:52]
13593 | `--RCURLY -> } [1263:4]
13594 |--METHOD_DEF -> METHOD_DEF [1265:4]
13595 | |--MODIFIERS -> MODIFIERS [1265:4]
13596 | | |--ANNOTATION -> ANNOTATION [1265:4]
13597 | | | |--AT -> @ [1265:4]
13598 | | | `--IDENT -> Test [1265:5]
13599 | | `--LITERAL_PUBLIC -> public [1266:4]
13600 | |--TYPE -> TYPE [1266:11]
13601 | | `--LITERAL_VOID -> void [1266:11]
13602 | |--IDENT -> testInvalidArrayInitWithTrueStrictCondition [1266:16]
13603 | |--LPAREN -> ( [1266:59]
13604 | |--PARAMETERS -> PARAMETERS [1266:60]
13605 | |--RPAREN -> ) [1266:60]
13606 | |--LITERAL_THROWS -> throws [1267:12]
13607 | | `--IDENT -> Exception [1267:19]
13608 | `--SLIST -> { [1267:29]
13609 | |--VARIABLE_DEF -> VARIABLE_DEF [1268:8]
13610 | | |--MODIFIERS -> MODIFIERS [1268:8]
13611 | | | `--FINAL -> final [1268:8]
13612 | | |--TYPE -> TYPE [1268:14]
13613 | | | `--IDENT -> DefaultConfiguration [1268:14]
13614 | | |--IDENT -> checkConfig [1268:35]
13615 | | `--ASSIGN -> = [1268:47]
13616 | | `--EXPR -> EXPR [1268:67]
13617 | | `--METHOD_CALL -> ( [1268:67]
13618 | | |--IDENT -> createModuleConfig [1268:49]
13619 | | |--ELIST -> ELIST [1268:84]
13620 | | | `--EXPR -> EXPR [1268:84]
13621 | | | `--DOT -> . [1268:84]
13622 | | | |--IDENT -> IndentationCheck [1268:68]
13623 | | | `--LITERAL_CLASS -> class [1268:85]
13624 | | `--RPAREN -> ) [1268:90]
13625 | |--SEMI -> ; [1268:91]
13626 | |--EXPR -> EXPR [1270:32]
13627 | | `--METHOD_CALL -> ( [1270:32]
13628 | | |--DOT -> . [1270:19]
13629 | | | |--IDENT -> checkConfig [1270:8]
13630 | | | `--IDENT -> addAttribute [1270:20]
13631 | | |--ELIST -> ELIST [1270:33]
13632 | | | |--EXPR -> EXPR [1270:33]
13633 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1270:33]
13634 | | | |--COMMA -> , [1270:50]
13635 | | | `--EXPR -> EXPR [1270:52]
13636 | | | `--STRING_LITERAL -> "4" [1270:52]
13637 | | `--RPAREN -> ) [1270:55]
13638 | |--SEMI -> ; [1270:56]
13639 | |--EXPR -> EXPR [1271:32]
13640 | | `--METHOD_CALL -> ( [1271:32]
13641 | | |--DOT -> . [1271:19]
13642 | | | |--IDENT -> checkConfig [1271:8]
13643 | | | `--IDENT -> addAttribute [1271:20]
13644 | | |--ELIST -> ELIST [1271:33]
13645 | | | |--EXPR -> EXPR [1271:33]
13646 | | | | `--STRING_LITERAL -> "basicOffset" [1271:33]
13647 | | | |--COMMA -> , [1271:46]
13648 | | | `--EXPR -> EXPR [1271:48]
13649 | | | `--STRING_LITERAL -> "4" [1271:48]
13650 | | `--RPAREN -> ) [1271:51]
13651 | |--SEMI -> ; [1271:52]
13652 | |--EXPR -> EXPR [1272:32]
13653 | | `--METHOD_CALL -> ( [1272:32]
13654 | | |--DOT -> . [1272:19]
13655 | | | |--IDENT -> checkConfig [1272:8]
13656 | | | `--IDENT -> addAttribute [1272:20]
13657 | | |--ELIST -> ELIST [1272:33]
13658 | | | |--EXPR -> EXPR [1272:33]
13659 | | | | `--STRING_LITERAL -> "braceAdjustment" [1272:33]
13660 | | | |--COMMA -> , [1272:50]
13661 | | | `--EXPR -> EXPR [1272:52]
13662 | | | `--STRING_LITERAL -> "0" [1272:52]
13663 | | `--RPAREN -> ) [1272:55]
13664 | |--SEMI -> ; [1272:56]
13665 | |--EXPR -> EXPR [1273:32]
13666 | | `--METHOD_CALL -> ( [1273:32]
13667 | | |--DOT -> . [1273:19]
13668 | | | |--IDENT -> checkConfig [1273:8]
13669 | | | `--IDENT -> addAttribute [1273:20]
13670 | | |--ELIST -> ELIST [1273:33]
13671 | | | |--EXPR -> EXPR [1273:33]
13672 | | | | `--STRING_LITERAL -> "caseIndent" [1273:33]
13673 | | | |--COMMA -> , [1273:45]
13674 | | | `--EXPR -> EXPR [1273:47]
13675 | | | `--STRING_LITERAL -> "4" [1273:47]
13676 | | `--RPAREN -> ) [1273:50]
13677 | |--SEMI -> ; [1273:51]
13678 | |--EXPR -> EXPR [1274:32]
13679 | | `--METHOD_CALL -> ( [1274:32]
13680 | | |--DOT -> . [1274:19]
13681 | | | |--IDENT -> checkConfig [1274:8]
13682 | | | `--IDENT -> addAttribute [1274:20]
13683 | | |--ELIST -> ELIST [1274:33]
13684 | | | |--EXPR -> EXPR [1274:33]
13685 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1274:33]
13686 | | | |--COMMA -> , [1274:55]
13687 | | | `--EXPR -> EXPR [1274:57]
13688 | | | `--STRING_LITERAL -> "true" [1274:57]
13689 | | `--RPAREN -> ) [1274:63]
13690 | |--SEMI -> ; [1274:64]
13691 | |--EXPR -> EXPR [1275:32]
13692 | | `--METHOD_CALL -> ( [1275:32]
13693 | | |--DOT -> . [1275:19]
13694 | | | |--IDENT -> checkConfig [1275:8]
13695 | | | `--IDENT -> addAttribute [1275:20]
13696 | | |--ELIST -> ELIST [1275:33]
13697 | | | |--EXPR -> EXPR [1275:33]
13698 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1275:33]
13699 | | | |--COMMA -> , [1275:58]
13700 | | | `--EXPR -> EXPR [1275:60]
13701 | | | `--STRING_LITERAL -> "4" [1275:60]
13702 | | `--RPAREN -> ) [1275:63]
13703 | |--SEMI -> ; [1275:64]
13704 | |--EXPR -> EXPR [1276:32]
13705 | | `--METHOD_CALL -> ( [1276:32]
13706 | | |--DOT -> . [1276:19]
13707 | | | |--IDENT -> checkConfig [1276:8]
13708 | | | `--IDENT -> addAttribute [1276:20]
13709 | | |--ELIST -> ELIST [1276:33]
13710 | | | |--EXPR -> EXPR [1276:33]
13711 | | | | `--STRING_LITERAL -> "tabWidth" [1276:33]
13712 | | | |--COMMA -> , [1276:43]
13713 | | | `--EXPR -> EXPR [1276:45]
13714 | | | `--STRING_LITERAL -> "4" [1276:45]
13715 | | `--RPAREN -> ) [1276:48]
13716 | |--SEMI -> ; [1276:49]
13717 | |--EXPR -> EXPR [1277:32]
13718 | | `--METHOD_CALL -> ( [1277:32]
13719 | | |--DOT -> . [1277:19]
13720 | | | |--IDENT -> checkConfig [1277:8]
13721 | | | `--IDENT -> addAttribute [1277:20]
13722 | | |--ELIST -> ELIST [1277:33]
13723 | | | |--EXPR -> EXPR [1277:33]
13724 | | | | `--STRING_LITERAL -> "throwsIndent" [1277:33]
13725 | | | |--COMMA -> , [1277:47]
13726 | | | `--EXPR -> EXPR [1277:49]
13727 | | | `--STRING_LITERAL -> "4" [1277:49]
13728 | | `--RPAREN -> ) [1277:52]
13729 | |--SEMI -> ; [1277:53]
13730 | |--VARIABLE_DEF -> VARIABLE_DEF [1278:8]
13731 | | |--MODIFIERS -> MODIFIERS [1278:8]
13732 | | | `--FINAL -> final [1278:8]
13733 | | |--TYPE -> TYPE [1278:14]
13734 | | | `--IDENT -> String [1278:14]
13735 | | |--IDENT -> fileName [1278:21]
13736 | | `--ASSIGN -> = [1278:30]
13737 | | `--EXPR -> EXPR [1278:39]
13738 | | `--METHOD_CALL -> ( [1278:39]
13739 | | |--IDENT -> getPath [1278:32]
13740 | | |--ELIST -> ELIST [1278:40]
13741 | | | `--EXPR -> EXPR [1278:40]
13742 | | | `--STRING_LITERAL -> "InputIndentationInvalidArrayInitIndent.java" [1278:40]
13743 | | `--RPAREN -> ) [1278:85]
13744 | |--SEMI -> ; [1278:86]
13745 | |--VARIABLE_DEF -> VARIABLE_DEF [1279:8]
13746 | | |--MODIFIERS -> MODIFIERS [1279:8]
13747 | | | `--FINAL -> final [1279:8]
13748 | | |--TYPE -> TYPE [1279:20]
13749 | | | `--ARRAY_DECLARATOR -> [ [1279:20]
13750 | | | |--IDENT -> String [1279:14]
13751 | | | `--RBRACK -> ] [1279:21]
13752 | | |--IDENT -> expected [1279:23]
13753 | | `--ASSIGN -> = [1279:32]
13754 | | `--ARRAY_INIT -> { [1279:34]
13755 | | |--EXPR -> EXPR [1280:21]
13756 | | | `--PLUS -> + [1280:21]
13757 | | | |--STRING_LITERAL -> "21:3: " [1280:12]
13758 | | | `--METHOD_CALL -> ( [1280:38]
13759 | | | |--IDENT -> getCheckMessage [1280:23]
13760 | | | |--ELIST -> ELIST [1280:39]
13761 | | | | |--EXPR -> EXPR [1280:39]
13762 | | | | | `--IDENT -> MSG_ERROR [1280:39]
13763 | | | | |--COMMA -> , [1280:48]
13764 | | | | |--EXPR -> EXPR [1280:50]
13765 | | | | | `--STRING_LITERAL -> "member def type" [1280:50]
13766 | | | | |--COMMA -> , [1280:67]
13767 | | | | |--EXPR -> EXPR [1280:69]
13768 | | | | | `--NUM_INT -> 2 [1280:69]
13769 | | | | |--COMMA -> , [1280:70]
13770 | | | | `--EXPR -> EXPR [1280:72]
13771 | | | | `--NUM_INT -> 4 [1280:72]
13772 | | | `--RPAREN -> ) [1280:73]
13773 | | |--COMMA -> , [1280:74]
13774 | | |--EXPR -> EXPR [1281:21]
13775 | | | `--PLUS -> + [1281:21]
13776 | | | |--STRING_LITERAL -> "22:7: " [1281:12]
13777 | | | `--METHOD_CALL -> ( [1281:38]
13778 | | | |--IDENT -> getCheckMessage [1281:23]
13779 | | | |--ELIST -> ELIST [1281:39]
13780 | | | | |--EXPR -> EXPR [1281:39]
13781 | | | | | `--IDENT -> MSG_ERROR [1281:39]
13782 | | | | |--COMMA -> , [1281:48]
13783 | | | | |--EXPR -> EXPR [1281:50]
13784 | | | | | `--STRING_LITERAL -> "member def type" [1281:50]
13785 | | | | |--COMMA -> , [1281:67]
13786 | | | | |--EXPR -> EXPR [1281:69]
13787 | | | | | `--NUM_INT -> 6 [1281:69]
13788 | | | | |--COMMA -> , [1281:70]
13789 | | | | `--EXPR -> EXPR [1281:72]
13790 | | | | `--NUM_INT -> 4 [1281:72]
13791 | | | `--RPAREN -> ) [1281:73]
13792 | | |--COMMA -> , [1281:74]
13793 | | |--EXPR -> EXPR [1282:21]
13794 | | | `--PLUS -> + [1282:21]
13795 | | | |--STRING_LITERAL -> "24:3: " [1282:12]
13796 | | | `--METHOD_CALL -> ( [1282:38]
13797 | | | |--IDENT -> getCheckMessage [1282:23]
13798 | | | |--ELIST -> ELIST [1282:39]
13799 | | | | |--EXPR -> EXPR [1282:39]
13800 | | | | | `--IDENT -> MSG_ERROR [1282:39]
13801 | | | | |--COMMA -> , [1282:48]
13802 | | | | |--EXPR -> EXPR [1282:50]
13803 | | | | | `--STRING_LITERAL -> "member def type" [1282:50]
13804 | | | | |--COMMA -> , [1282:67]
13805 | | | | |--EXPR -> EXPR [1282:69]
13806 | | | | | `--NUM_INT -> 2 [1282:69]
13807 | | | | |--COMMA -> , [1282:70]
13808 | | | | `--EXPR -> EXPR [1282:72]
13809 | | | | `--NUM_INT -> 4 [1282:72]
13810 | | | `--RPAREN -> ) [1282:73]
13811 | | |--COMMA -> , [1282:74]
13812 | | |--EXPR -> EXPR [1283:21]
13813 | | | `--PLUS -> + [1283:21]
13814 | | | |--STRING_LITERAL -> "28:7: " [1283:12]
13815 | | | `--METHOD_CALL -> ( [1283:38]
13816 | | | |--IDENT -> getCheckMessage [1283:23]
13817 | | | |--ELIST -> ELIST [1283:39]
13818 | | | | |--EXPR -> EXPR [1283:39]
13819 | | | | | `--IDENT -> MSG_ERROR [1283:39]
13820 | | | | |--COMMA -> , [1283:48]
13821 | | | | |--EXPR -> EXPR [1283:50]
13822 | | | | | `--STRING_LITERAL -> "member def type" [1283:50]
13823 | | | | |--COMMA -> , [1283:67]
13824 | | | | |--EXPR -> EXPR [1283:69]
13825 | | | | | `--NUM_INT -> 6 [1283:69]
13826 | | | | |--COMMA -> , [1283:70]
13827 | | | | `--EXPR -> EXPR [1283:72]
13828 | | | | `--NUM_INT -> 4 [1283:72]
13829 | | | `--RPAREN -> ) [1283:73]
13830 | | |--COMMA -> , [1283:74]
13831 | | |--EXPR -> EXPR [1284:21]
13832 | | | `--PLUS -> + [1284:21]
13833 | | | |--STRING_LITERAL -> "29:9: " [1284:12]
13834 | | | `--METHOD_CALL -> ( [1284:38]
13835 | | | |--IDENT -> getCheckMessage [1284:23]
13836 | | | |--ELIST -> ELIST [1284:39]
13837 | | | | |--EXPR -> EXPR [1284:39]
13838 | | | | | `--IDENT -> MSG_CHILD_ERROR [1284:39]
13839 | | | | |--COMMA -> , [1284:54]
13840 | | | | |--EXPR -> EXPR [1284:56]
13841 | | | | | `--STRING_LITERAL -> "array initialization" [1284:56]
13842 | | | | |--COMMA -> , [1284:78]
13843 | | | | |--EXPR -> EXPR [1284:80]
13844 | | | | | `--NUM_INT -> 8 [1284:80]
13845 | | | | |--COMMA -> , [1284:81]
13846 | | | | `--EXPR -> EXPR [1284:83]
13847 | | | | `--NUM_INT -> 10 [1284:83]
13848 | | | `--RPAREN -> ) [1284:85]
13849 | | |--COMMA -> , [1284:86]
13850 | | |--EXPR -> EXPR [1285:21]
13851 | | | `--PLUS -> + [1285:21]
13852 | | | |--STRING_LITERAL -> "30:5: " [1285:12]
13853 | | | `--METHOD_CALL -> ( [1285:38]
13854 | | | |--IDENT -> getCheckMessage [1285:23]
13855 | | | |--ELIST -> ELIST [1285:39]
13856 | | | | |--EXPR -> EXPR [1285:39]
13857 | | | | | `--IDENT -> MSG_ERROR_MULTI [1285:39]
13858 | | | | |--COMMA -> , [1285:54]
13859 | | | | |--EXPR -> EXPR [1285:56]
13860 | | | | | `--STRING_LITERAL -> "array initialization rcurly" [1285:56]
13861 | | | | |--COMMA -> , [1285:85]
13862 | | | | |--EXPR -> EXPR [1285:87]
13863 | | | | | `--NUM_INT -> 4 [1285:87]
13864 | | | | |--COMMA -> , [1285:88]
13865 | | | | `--EXPR -> EXPR [1285:90]
13866 | | | | `--STRING_LITERAL -> "6, 10" [1285:90]
13867 | | | `--RPAREN -> ) [1285:97]
13868 | | |--COMMA -> , [1285:98]
13869 | | |--EXPR -> EXPR [1286:22]
13870 | | | `--PLUS -> + [1286:22]
13871 | | | |--STRING_LITERAL -> "33:10: " [1286:12]
13872 | | | `--METHOD_CALL -> ( [1286:39]
13873 | | | |--IDENT -> getCheckMessage [1286:24]
13874 | | | |--ELIST -> ELIST [1286:40]
13875 | | | | |--EXPR -> EXPR [1286:40]
13876 | | | | | `--IDENT -> MSG_CHILD_ERROR [1286:40]
13877 | | | | |--COMMA -> , [1286:55]
13878 | | | | |--EXPR -> EXPR [1286:57]
13879 | | | | | `--STRING_LITERAL -> "array initialization" [1286:57]
13880 | | | | |--COMMA -> , [1286:79]
13881 | | | | |--EXPR -> EXPR [1286:81]
13882 | | | | | `--NUM_INT -> 9 [1286:81]
13883 | | | | |--COMMA -> , [1286:82]
13884 | | | | `--EXPR -> EXPR [1286:84]
13885 | | | | `--NUM_INT -> 8 [1286:84]
13886 | | | `--RPAREN -> ) [1286:85]
13887 | | |--COMMA -> , [1286:86]
13888 | | |--EXPR -> EXPR [1287:21]
13889 | | | `--PLUS -> + [1287:21]
13890 | | | |--STRING_LITERAL -> "34:8: " [1287:12]
13891 | | | `--METHOD_CALL -> ( [1287:38]
13892 | | | |--IDENT -> getCheckMessage [1287:23]
13893 | | | |--ELIST -> ELIST [1287:39]
13894 | | | | |--EXPR -> EXPR [1287:39]
13895 | | | | | `--IDENT -> MSG_CHILD_ERROR [1287:39]
13896 | | | | |--COMMA -> , [1287:54]
13897 | | | | |--EXPR -> EXPR [1287:56]
13898 | | | | | `--STRING_LITERAL -> "array initialization" [1287:56]
13899 | | | | |--COMMA -> , [1287:78]
13900 | | | | |--EXPR -> EXPR [1287:80]
13901 | | | | | `--NUM_INT -> 7 [1287:80]
13902 | | | | |--COMMA -> , [1287:81]
13903 | | | | `--EXPR -> EXPR [1287:83]
13904 | | | | `--NUM_INT -> 8 [1287:83]
13905 | | | `--RPAREN -> ) [1287:84]
13906 | | |--COMMA -> , [1287:85]
13907 | | |--EXPR -> EXPR [1288:22]
13908 | | | `--PLUS -> + [1288:22]
13909 | | | |--STRING_LITERAL -> "35:10: " [1288:12]
13910 | | | `--METHOD_CALL -> ( [1288:39]
13911 | | | |--IDENT -> getCheckMessage [1288:24]
13912 | | | |--ELIST -> ELIST [1288:40]
13913 | | | | |--EXPR -> EXPR [1288:40]
13914 | | | | | `--IDENT -> MSG_CHILD_ERROR [1288:40]
13915 | | | | |--COMMA -> , [1288:55]
13916 | | | | |--EXPR -> EXPR [1288:57]
13917 | | | | | `--STRING_LITERAL -> "array initialization" [1288:57]
13918 | | | | |--COMMA -> , [1288:79]
13919 | | | | |--EXPR -> EXPR [1288:81]
13920 | | | | | `--NUM_INT -> 9 [1288:81]
13921 | | | | |--COMMA -> , [1288:82]
13922 | | | | `--EXPR -> EXPR [1288:84]
13923 | | | | `--NUM_INT -> 8 [1288:84]
13924 | | | `--RPAREN -> ) [1288:85]
13925 | | |--COMMA -> , [1288:86]
13926 | | |--EXPR -> EXPR [1289:21]
13927 | | | `--PLUS -> + [1289:21]
13928 | | | |--STRING_LITERAL -> "40:3: " [1289:12]
13929 | | | `--METHOD_CALL -> ( [1289:38]
13930 | | | |--IDENT -> getCheckMessage [1289:23]
13931 | | | |--ELIST -> ELIST [1289:39]
13932 | | | | |--EXPR -> EXPR [1289:39]
13933 | | | | | `--IDENT -> MSG_ERROR_MULTI [1289:39]
13934 | | | | |--COMMA -> , [1289:54]
13935 | | | | |--EXPR -> EXPR [1289:56]
13936 | | | | | `--STRING_LITERAL -> "array initialization lcurly" [1289:56]
13937 | | | | |--COMMA -> , [1289:85]
13938 | | | | |--EXPR -> EXPR [1289:87]
13939 | | | | | `--NUM_INT -> 2 [1289:87]
13940 | | | | |--COMMA -> , [1289:88]
13941 | | | | `--EXPR -> EXPR [1289:90]
13942 | | | | `--STRING_LITERAL -> "4, 8" [1289:90]
13943 | | | `--RPAREN -> ) [1289:96]
13944 | | |--COMMA -> , [1289:97]
13945 | | |--EXPR -> EXPR [1290:21]
13946 | | | `--PLUS -> + [1290:21]
13947 | | | |--STRING_LITERAL -> "44:7: " [1290:12]
13948 | | | `--METHOD_CALL -> ( [1290:38]
13949 | | | |--IDENT -> getCheckMessage [1290:23]
13950 | | | |--ELIST -> ELIST [1290:39]
13951 | | | | |--EXPR -> EXPR [1290:39]
13952 | | | | | `--IDENT -> MSG_ERROR_MULTI [1290:39]
13953 | | | | |--COMMA -> , [1290:54]
13954 | | | | |--EXPR -> EXPR [1290:56]
13955 | | | | | `--STRING_LITERAL -> "array initialization rcurly" [1290:56]
13956 | | | | |--COMMA -> , [1290:85]
13957 | | | | |--EXPR -> EXPR [1290:87]
13958 | | | | | `--NUM_INT -> 6 [1290:87]
13959 | | | | |--COMMA -> , [1290:88]
13960 | | | | `--EXPR -> EXPR [1290:90]
13961 | | | | `--STRING_LITERAL -> "4, 8" [1290:90]
13962 | | | `--RPAREN -> ) [1290:96]
13963 | | |--COMMA -> , [1290:97]
13964 | | |--EXPR -> EXPR [1291:21]
13965 | | | `--PLUS -> + [1291:21]
13966 | | | |--STRING_LITERAL -> "48:3: " [1291:12]
13967 | | | `--METHOD_CALL -> ( [1291:38]
13968 | | | |--IDENT -> getCheckMessage [1291:23]
13969 | | | |--ELIST -> ELIST [1291:39]
13970 | | | | |--EXPR -> EXPR [1291:39]
13971 | | | | | `--IDENT -> MSG_ERROR_MULTI [1291:39]
13972 | | | | |--COMMA -> , [1291:54]
13973 | | | | |--EXPR -> EXPR [1291:56]
13974 | | | | | `--STRING_LITERAL -> "array initialization lcurly" [1291:56]
13975 | | | | |--COMMA -> , [1291:85]
13976 | | | | |--EXPR -> EXPR [1291:87]
13977 | | | | | `--NUM_INT -> 2 [1291:87]
13978 | | | | |--COMMA -> , [1291:88]
13979 | | | | `--EXPR -> EXPR [1291:90]
13980 | | | | `--STRING_LITERAL -> "4, 8" [1291:90]
13981 | | | `--RPAREN -> ) [1291:96]
13982 | | |--COMMA -> , [1291:97]
13983 | | |--EXPR -> EXPR [1292:22]
13984 | | | `--PLUS -> + [1292:22]
13985 | | | |--STRING_LITERAL -> "52:21: " [1292:12]
13986 | | | `--METHOD_CALL -> ( [1292:39]
13987 | | | |--IDENT -> getCheckMessage [1292:24]
13988 | | | |--ELIST -> ELIST [1292:40]
13989 | | | | |--EXPR -> EXPR [1292:40]
13990 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [1292:40]
13991 | | | | |--COMMA -> , [1292:61]
13992 | | | | |--EXPR -> EXPR [1292:63]
13993 | | | | | `--STRING_LITERAL -> "array initialization" [1292:63]
13994 | | | | |--COMMA -> , [1292:85]
13995 | | | | |--EXPR -> EXPR [1292:87]
13996 | | | | | `--NUM_INT -> 20 [1292:87]
13997 | | | | |--COMMA -> , [1292:89]
13998 | | | | `--EXPR -> EXPR [1293:16]
13999 | | | | `--STRING_LITERAL -> "8, 31, 33" [1293:16]
14000 | | | `--RPAREN -> ) [1293:27]
14001 | | |--COMMA -> , [1293:28]
14002 | | |--EXPR -> EXPR [1294:21]
14003 | | | `--PLUS -> + [1294:21]
14004 | | | |--STRING_LITERAL -> "53:5: " [1294:12]
14005 | | | `--METHOD_CALL -> ( [1294:38]
14006 | | | |--IDENT -> getCheckMessage [1294:23]
14007 | | | |--ELIST -> ELIST [1294:39]
14008 | | | | |--EXPR -> EXPR [1294:39]
14009 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [1294:39]
14010 | | | | |--COMMA -> , [1294:60]
14011 | | | | |--EXPR -> EXPR [1294:62]
14012 | | | | | `--STRING_LITERAL -> "array initialization" [1294:62]
14013 | | | | |--COMMA -> , [1294:84]
14014 | | | | |--EXPR -> EXPR [1295:16]
14015 | | | | | `--NUM_INT -> 4 [1295:16]
14016 | | | | |--COMMA -> , [1295:17]
14017 | | | | `--EXPR -> EXPR [1295:19]
14018 | | | | `--STRING_LITERAL -> "8, 31, 33" [1295:19]
14019 | | | `--RPAREN -> ) [1295:30]
14020 | | |--COMMA -> , [1295:31]
14021 | | |--EXPR -> EXPR [1296:21]
14022 | | | `--PLUS -> + [1296:21]
14023 | | | |--STRING_LITERAL -> "58:7: " [1296:12]
14024 | | | `--METHOD_CALL -> ( [1296:38]
14025 | | | |--IDENT -> getCheckMessage [1296:23]
14026 | | | |--ELIST -> ELIST [1296:39]
14027 | | | | |--EXPR -> EXPR [1296:39]
14028 | | | | | `--IDENT -> MSG_CHILD_ERROR [1296:39]
14029 | | | | |--COMMA -> , [1296:54]
14030 | | | | |--EXPR -> EXPR [1296:56]
14031 | | | | | `--STRING_LITERAL -> "array initialization" [1296:56]
14032 | | | | |--COMMA -> , [1296:78]
14033 | | | | |--EXPR -> EXPR [1296:80]
14034 | | | | | `--NUM_INT -> 6 [1296:80]
14035 | | | | |--COMMA -> , [1296:81]
14036 | | | | `--EXPR -> EXPR [1296:83]
14037 | | | | `--NUM_INT -> 8 [1296:83]
14038 | | | `--RPAREN -> ) [1296:84]
14039 | | |--COMMA -> , [1296:85]
14040 | | |--EXPR -> EXPR [1297:21]
14041 | | | `--PLUS -> + [1297:21]
14042 | | | |--STRING_LITERAL -> "63:3: " [1297:12]
14043 | | | `--METHOD_CALL -> ( [1297:38]
14044 | | | |--IDENT -> getCheckMessage [1297:23]
14045 | | | |--ELIST -> ELIST [1297:39]
14046 | | | | |--EXPR -> EXPR [1297:39]
14047 | | | | | `--IDENT -> MSG_ERROR [1297:39]
14048 | | | | |--COMMA -> , [1297:48]
14049 | | | | |--EXPR -> EXPR [1297:50]
14050 | | | | | `--STRING_LITERAL -> "member def type" [1297:50]
14051 | | | | |--COMMA -> , [1297:67]
14052 | | | | |--EXPR -> EXPR [1297:69]
14053 | | | | | `--NUM_INT -> 2 [1297:69]
14054 | | | | |--COMMA -> , [1297:70]
14055 | | | | `--EXPR -> EXPR [1297:72]
14056 | | | | `--NUM_INT -> 4 [1297:72]
14057 | | | `--RPAREN -> ) [1297:73]
14058 | | |--COMMA -> , [1297:74]
14059 | | |--EXPR -> EXPR [1298:21]
14060 | | | `--PLUS -> + [1298:21]
14061 | | | |--STRING_LITERAL -> "65:7: " [1298:12]
14062 | | | `--METHOD_CALL -> ( [1298:38]
14063 | | | |--IDENT -> getCheckMessage [1298:23]
14064 | | | |--ELIST -> ELIST [1298:39]
14065 | | | | |--EXPR -> EXPR [1298:39]
14066 | | | | | `--IDENT -> MSG_ERROR [1298:39]
14067 | | | | |--COMMA -> , [1298:48]
14068 | | | | |--EXPR -> EXPR [1298:50]
14069 | | | | | `--STRING_LITERAL -> "member def type" [1298:50]
14070 | | | | |--COMMA -> , [1298:67]
14071 | | | | |--EXPR -> EXPR [1298:69]
14072 | | | | | `--NUM_INT -> 6 [1298:69]
14073 | | | | |--COMMA -> , [1298:70]
14074 | | | | `--EXPR -> EXPR [1298:72]
14075 | | | | `--NUM_INT -> 4 [1298:72]
14076 | | | `--RPAREN -> ) [1298:73]
14077 | | |--COMMA -> , [1298:74]
14078 | | |--EXPR -> EXPR [1299:21]
14079 | | | `--PLUS -> + [1299:21]
14080 | | | |--STRING_LITERAL -> "66:3: " [1299:12]
14081 | | | `--METHOD_CALL -> ( [1299:38]
14082 | | | |--IDENT -> getCheckMessage [1299:23]
14083 | | | |--ELIST -> ELIST [1299:39]
14084 | | | | |--EXPR -> EXPR [1299:39]
14085 | | | | | `--IDENT -> MSG_ERROR_MULTI [1299:39]
14086 | | | | |--COMMA -> , [1299:54]
14087 | | | | |--EXPR -> EXPR [1299:56]
14088 | | | | | `--STRING_LITERAL -> "array initialization rcurly" [1299:56]
14089 | | | | |--COMMA -> , [1299:85]
14090 | | | | |--EXPR -> EXPR [1299:87]
14091 | | | | | `--NUM_INT -> 2 [1299:87]
14092 | | | | |--COMMA -> , [1299:88]
14093 | | | | `--EXPR -> EXPR [1299:90]
14094 | | | | `--STRING_LITERAL -> "6, 10" [1299:90]
14095 | | | `--RPAREN -> ) [1299:97]
14096 | | |--COMMA -> , [1299:98]
14097 | | |--EXPR -> EXPR [1300:21]
14098 | | | `--PLUS -> + [1300:21]
14099 | | | |--STRING_LITERAL -> "69:7: " [1300:12]
14100 | | | `--METHOD_CALL -> ( [1300:38]
14101 | | | |--IDENT -> getCheckMessage [1300:23]
14102 | | | |--ELIST -> ELIST [1300:39]
14103 | | | | |--EXPR -> EXPR [1300:39]
14104 | | | | | `--IDENT -> MSG_CHILD_ERROR [1300:39]
14105 | | | | |--COMMA -> , [1300:54]
14106 | | | | |--EXPR -> EXPR [1300:56]
14107 | | | | | `--STRING_LITERAL -> "array initialization" [1300:56]
14108 | | | | |--COMMA -> , [1300:78]
14109 | | | | |--EXPR -> EXPR [1300:80]
14110 | | | | | `--NUM_INT -> 6 [1300:80]
14111 | | | | |--COMMA -> , [1300:81]
14112 | | | | `--EXPR -> EXPR [1300:83]
14113 | | | | `--NUM_INT -> 8 [1300:83]
14114 | | | `--RPAREN -> ) [1300:84]
14115 | | |--COMMA -> , [1300:85]
14116 | | |--EXPR -> EXPR [1301:22]
14117 | | | `--PLUS -> + [1301:22]
14118 | | | |--STRING_LITERAL -> "76:11: " [1301:12]
14119 | | | `--METHOD_CALL -> ( [1301:39]
14120 | | | |--IDENT -> getCheckMessage [1301:24]
14121 | | | |--ELIST -> ELIST [1301:40]
14122 | | | | |--EXPR -> EXPR [1301:40]
14123 | | | | | `--IDENT -> MSG_CHILD_ERROR [1301:40]
14124 | | | | |--COMMA -> , [1301:55]
14125 | | | | |--EXPR -> EXPR [1301:57]
14126 | | | | | `--STRING_LITERAL -> "array initialization" [1301:57]
14127 | | | | |--COMMA -> , [1301:79]
14128 | | | | |--EXPR -> EXPR [1301:81]
14129 | | | | | `--NUM_INT -> 10 [1301:81]
14130 | | | | |--COMMA -> , [1301:83]
14131 | | | | `--EXPR -> EXPR [1301:85]
14132 | | | | `--NUM_INT -> 12 [1301:85]
14133 | | | `--RPAREN -> ) [1301:87]
14134 | | |--COMMA -> , [1301:88]
14135 | | |--EXPR -> EXPR [1302:21]
14136 | | | `--PLUS -> + [1302:21]
14137 | | | |--STRING_LITERAL -> "89:9: " [1302:12]
14138 | | | `--METHOD_CALL -> ( [1302:38]
14139 | | | |--IDENT -> getCheckMessage [1302:23]
14140 | | | |--ELIST -> ELIST [1302:39]
14141 | | | | |--EXPR -> EXPR [1302:39]
14142 | | | | | `--IDENT -> MSG_ERROR [1302:39]
14143 | | | | |--COMMA -> , [1302:48]
14144 | | | | |--EXPR -> EXPR [1302:50]
14145 | | | | | `--STRING_LITERAL -> "1" [1302:50]
14146 | | | | |--COMMA -> , [1302:53]
14147 | | | | |--EXPR -> EXPR [1302:55]
14148 | | | | | `--NUM_INT -> 8 [1302:55]
14149 | | | | |--COMMA -> , [1302:56]
14150 | | | | `--EXPR -> EXPR [1302:58]
14151 | | | | `--NUM_INT -> 12 [1302:58]
14152 | | | `--RPAREN -> ) [1302:60]
14153 | | |--COMMA -> , [1302:61]
14154 | | |--EXPR -> EXPR [1303:23]
14155 | | | `--PLUS -> + [1303:23]
14156 | | | |--STRING_LITERAL -> "100:11: " [1303:12]
14157 | | | `--METHOD_CALL -> ( [1303:40]
14158 | | | |--IDENT -> getCheckMessage [1303:25]
14159 | | | |--ELIST -> ELIST [1303:41]
14160 | | | | |--EXPR -> EXPR [1303:41]
14161 | | | | | `--IDENT -> MSG_CHILD_ERROR [1303:41]
14162 | | | | |--COMMA -> , [1303:56]
14163 | | | | |--EXPR -> EXPR [1303:58]
14164 | | | | | `--STRING_LITERAL -> "array initialization" [1303:58]
14165 | | | | |--COMMA -> , [1303:80]
14166 | | | | |--EXPR -> EXPR [1303:82]
14167 | | | | | `--NUM_INT -> 10 [1303:82]
14168 | | | | |--COMMA -> , [1303:84]
14169 | | | | `--EXPR -> EXPR [1303:86]
14170 | | | | `--NUM_INT -> 12 [1303:86]
14171 | | | `--RPAREN -> ) [1303:88]
14172 | | |--COMMA -> , [1303:89]
14173 | | |--EXPR -> EXPR [1304:23]
14174 | | | `--PLUS -> + [1304:23]
14175 | | | |--STRING_LITERAL -> "101:15: " [1304:12]
14176 | | | `--METHOD_CALL -> ( [1304:40]
14177 | | | |--IDENT -> getCheckMessage [1304:25]
14178 | | | |--ELIST -> ELIST [1304:41]
14179 | | | | |--EXPR -> EXPR [1304:41]
14180 | | | | | `--IDENT -> MSG_CHILD_ERROR [1304:41]
14181 | | | | |--COMMA -> , [1304:56]
14182 | | | | |--EXPR -> EXPR [1304:58]
14183 | | | | | `--STRING_LITERAL -> "array initialization" [1304:58]
14184 | | | | |--COMMA -> , [1304:80]
14185 | | | | |--EXPR -> EXPR [1304:82]
14186 | | | | | `--NUM_INT -> 14 [1304:82]
14187 | | | | |--COMMA -> , [1304:84]
14188 | | | | `--EXPR -> EXPR [1304:86]
14189 | | | | `--NUM_INT -> 12 [1304:86]
14190 | | | `--RPAREN -> ) [1304:88]
14191 | | |--COMMA -> , [1304:89]
14192 | | |--EXPR -> EXPR [1305:23]
14193 | | | `--PLUS -> + [1305:23]
14194 | | | |--STRING_LITERAL -> "104:11: " [1305:12]
14195 | | | `--METHOD_CALL -> ( [1305:40]
14196 | | | |--IDENT -> getCheckMessage [1305:25]
14197 | | | |--ELIST -> ELIST [1305:41]
14198 | | | | |--EXPR -> EXPR [1305:41]
14199 | | | | | `--IDENT -> MSG_CHILD_ERROR [1305:41]
14200 | | | | |--COMMA -> , [1305:56]
14201 | | | | |--EXPR -> EXPR [1305:58]
14202 | | | | | `--STRING_LITERAL -> "array initialization" [1305:58]
14203 | | | | |--COMMA -> , [1305:80]
14204 | | | | |--EXPR -> EXPR [1305:82]
14205 | | | | | `--NUM_INT -> 10 [1305:82]
14206 | | | | |--COMMA -> , [1305:84]
14207 | | | | `--EXPR -> EXPR [1305:86]
14208 | | | | `--NUM_INT -> 12 [1305:86]
14209 | | | `--RPAREN -> ) [1305:88]
14210 | | |--COMMA -> , [1305:89]
14211 | | |--EXPR -> EXPR [1306:23]
14212 | | | `--PLUS -> + [1306:23]
14213 | | | |--STRING_LITERAL -> "105:15: " [1306:12]
14214 | | | `--METHOD_CALL -> ( [1306:40]
14215 | | | |--IDENT -> getCheckMessage [1306:25]
14216 | | | |--ELIST -> ELIST [1306:41]
14217 | | | | |--EXPR -> EXPR [1306:41]
14218 | | | | | `--IDENT -> MSG_CHILD_ERROR [1306:41]
14219 | | | | |--COMMA -> , [1306:56]
14220 | | | | |--EXPR -> EXPR [1306:58]
14221 | | | | | `--STRING_LITERAL -> "array initialization" [1306:58]
14222 | | | | |--COMMA -> , [1306:80]
14223 | | | | |--EXPR -> EXPR [1306:82]
14224 | | | | | `--NUM_INT -> 14 [1306:82]
14225 | | | | |--COMMA -> , [1306:84]
14226 | | | | `--EXPR -> EXPR [1306:86]
14227 | | | | `--NUM_INT -> 12 [1306:86]
14228 | | | `--RPAREN -> ) [1306:88]
14229 | | |--COMMA -> , [1306:89]
14230 | | |--EXPR -> EXPR [1307:22]
14231 | | | `--PLUS -> + [1307:22]
14232 | | | |--STRING_LITERAL -> "106:7: " [1307:12]
14233 | | | `--METHOD_CALL -> ( [1307:39]
14234 | | | |--IDENT -> getCheckMessage [1307:24]
14235 | | | |--ELIST -> ELIST [1307:40]
14236 | | | | |--EXPR -> EXPR [1307:40]
14237 | | | | | `--IDENT -> MSG_ERROR_MULTI [1307:40]
14238 | | | | |--COMMA -> , [1307:55]
14239 | | | | |--EXPR -> EXPR [1307:57]
14240 | | | | | `--STRING_LITERAL -> "array initialization rcurly" [1307:57]
14241 | | | | |--COMMA -> , [1307:86]
14242 | | | | |--EXPR -> EXPR [1307:88]
14243 | | | | | `--NUM_INT -> 6 [1307:88]
14244 | | | | |--COMMA -> , [1307:89]
14245 | | | | `--EXPR -> EXPR [1307:91]
14246 | | | | `--STRING_LITERAL -> "8, 12" [1307:91]
14247 | | | `--RPAREN -> ) [1307:98]
14248 | | |--COMMA -> , [1307:99]
14249 | | |--EXPR -> EXPR [1308:22]
14250 | | | `--PLUS -> + [1308:22]
14251 | | | |--STRING_LITERAL -> "109:7: " [1308:12]
14252 | | | `--METHOD_CALL -> ( [1308:39]
14253 | | | |--IDENT -> getCheckMessage [1308:24]
14254 | | | |--ELIST -> ELIST [1308:40]
14255 | | | | |--EXPR -> EXPR [1308:40]
14256 | | | | | `--IDENT -> MSG_ERROR_MULTI [1308:40]
14257 | | | | |--COMMA -> , [1308:55]
14258 | | | | |--EXPR -> EXPR [1308:57]
14259 | | | | | `--STRING_LITERAL -> "array initialization lcurly" [1308:57]
14260 | | | | |--COMMA -> , [1308:86]
14261 | | | | |--EXPR -> EXPR [1308:88]
14262 | | | | | `--NUM_INT -> 6 [1308:88]
14263 | | | | |--COMMA -> , [1308:89]
14264 | | | | `--EXPR -> EXPR [1308:91]
14265 | | | | `--STRING_LITERAL -> "8, 12" [1308:91]
14266 | | | `--RPAREN -> ) [1308:98]
14267 | | |--COMMA -> , [1308:99]
14268 | | |--EXPR -> EXPR [1309:23]
14269 | | | `--PLUS -> + [1309:23]
14270 | | | |--STRING_LITERAL -> "110:15: " [1309:12]
14271 | | | `--METHOD_CALL -> ( [1309:40]
14272 | | | |--IDENT -> getCheckMessage [1309:25]
14273 | | | |--ELIST -> ELIST [1309:41]
14274 | | | | |--EXPR -> EXPR [1309:41]
14275 | | | | | `--IDENT -> MSG_CHILD_ERROR [1309:41]
14276 | | | | |--COMMA -> , [1309:56]
14277 | | | | |--EXPR -> EXPR [1309:58]
14278 | | | | | `--STRING_LITERAL -> "array initialization" [1309:58]
14279 | | | | |--COMMA -> , [1309:80]
14280 | | | | |--EXPR -> EXPR [1309:82]
14281 | | | | | `--NUM_INT -> 14 [1309:82]
14282 | | | | |--COMMA -> , [1309:84]
14283 | | | | `--EXPR -> EXPR [1309:86]
14284 | | | | `--NUM_INT -> 12 [1309:86]
14285 | | | `--RPAREN -> ) [1309:88]
14286 | | |--COMMA -> , [1309:89]
14287 | | |--EXPR -> EXPR [1310:23]
14288 | | | `--PLUS -> + [1310:23]
14289 | | | |--STRING_LITERAL -> "111:11: " [1310:12]
14290 | | | `--METHOD_CALL -> ( [1310:40]
14291 | | | |--IDENT -> getCheckMessage [1310:25]
14292 | | | |--ELIST -> ELIST [1310:41]
14293 | | | | |--EXPR -> EXPR [1310:41]
14294 | | | | | `--IDENT -> MSG_CHILD_ERROR [1310:41]
14295 | | | | |--COMMA -> , [1310:56]
14296 | | | | |--EXPR -> EXPR [1310:58]
14297 | | | | | `--STRING_LITERAL -> "array initialization" [1310:58]
14298 | | | | |--COMMA -> , [1310:80]
14299 | | | | |--EXPR -> EXPR [1310:82]
14300 | | | | | `--NUM_INT -> 10 [1310:82]
14301 | | | | |--COMMA -> , [1310:84]
14302 | | | | `--EXPR -> EXPR [1310:86]
14303 | | | | `--NUM_INT -> 12 [1310:86]
14304 | | | `--RPAREN -> ) [1310:88]
14305 | | |--COMMA -> , [1310:89]
14306 | | |--EXPR -> EXPR [1311:22]
14307 | | | `--PLUS -> + [1311:22]
14308 | | | |--STRING_LITERAL -> "112:7: " [1311:12]
14309 | | | `--METHOD_CALL -> ( [1311:39]
14310 | | | |--IDENT -> getCheckMessage [1311:24]
14311 | | | |--ELIST -> ELIST [1311:40]
14312 | | | | |--EXPR -> EXPR [1311:40]
14313 | | | | | `--IDENT -> MSG_ERROR_MULTI [1311:40]
14314 | | | | |--COMMA -> , [1311:55]
14315 | | | | |--EXPR -> EXPR [1311:57]
14316 | | | | | `--STRING_LITERAL -> "array initialization rcurly" [1311:57]
14317 | | | | |--COMMA -> , [1311:86]
14318 | | | | |--EXPR -> EXPR [1311:88]
14319 | | | | | `--NUM_INT -> 6 [1311:88]
14320 | | | | |--COMMA -> , [1311:89]
14321 | | | | `--EXPR -> EXPR [1311:91]
14322 | | | | `--STRING_LITERAL -> "8, 12" [1311:91]
14323 | | | `--RPAREN -> ) [1311:98]
14324 | | |--COMMA -> , [1311:99]
14325 | | |--EXPR -> EXPR [1313:23]
14326 | | | `--PLUS -> + [1313:23]
14327 | | | |--SINGLE_LINE_COMMENT -> // [1312:12]
14328 | | | | `--COMMENT_CONTENT -> following are tests for annotation array initialisation\n [1312:14]
14329 | | | |--STRING_LITERAL -> "120:13: " [1313:12]
14330 | | | `--METHOD_CALL -> ( [1313:40]
14331 | | | |--IDENT -> getCheckMessage [1313:25]
14332 | | | |--ELIST -> ELIST [1313:41]
14333 | | | | |--EXPR -> EXPR [1313:41]
14334 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [1313:41]
14335 | | | | |--COMMA -> , [1313:62]
14336 | | | | |--EXPR -> EXPR [1313:64]
14337 | | | | | `--STRING_LITERAL -> "annotation array initialization" [1313:64]
14338 | | | | |--COMMA -> , [1313:97]
14339 | | | | |--EXPR -> EXPR [1314:16]
14340 | | | | | `--NUM_INT -> 12 [1314:16]
14341 | | | | |--COMMA -> , [1314:18]
14342 | | | | `--EXPR -> EXPR [1314:20]
14343 | | | | `--STRING_LITERAL -> "16, 46, 48" [1314:20]
14344 | | | `--RPAREN -> ) [1314:32]
14345 | | |--COMMA -> , [1314:33]
14346 | | |--EXPR -> EXPR [1315:23]
14347 | | | `--PLUS -> + [1315:23]
14348 | | | |--STRING_LITERAL -> "124:15: " [1315:12]
14349 | | | `--METHOD_CALL -> ( [1315:40]
14350 | | | |--IDENT -> getCheckMessage [1315:25]
14351 | | | |--ELIST -> ELIST [1315:41]
14352 | | | | |--EXPR -> EXPR [1315:41]
14353 | | | | | `--IDENT -> MSG_CHILD_ERROR [1315:41]
14354 | | | | |--COMMA -> , [1315:56]
14355 | | | | |--EXPR -> EXPR [1315:58]
14356 | | | | | `--STRING_LITERAL -> "annotation array initialization" [1315:58]
14357 | | | | |--COMMA -> , [1315:91]
14358 | | | | |--EXPR -> EXPR [1316:16]
14359 | | | | | `--NUM_INT -> 14 [1316:16]
14360 | | | | |--COMMA -> , [1316:18]
14361 | | | | `--EXPR -> EXPR [1316:20]
14362 | | | | `--NUM_INT -> 12 [1316:20]
14363 | | | `--RPAREN -> ) [1316:22]
14364 | | |--COMMA -> , [1316:23]
14365 | | |--EXPR -> EXPR [1317:23]
14366 | | | `--PLUS -> + [1317:23]
14367 | | | |--STRING_LITERAL -> "128:15: " [1317:12]
14368 | | | `--METHOD_CALL -> ( [1317:40]
14369 | | | |--IDENT -> getCheckMessage [1317:25]
14370 | | | |--ELIST -> ELIST [1317:41]
14371 | | | | |--EXPR -> EXPR [1317:41]
14372 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [1317:41]
14373 | | | | |--COMMA -> , [1317:62]
14374 | | | | |--EXPR -> EXPR [1317:64]
14375 | | | | | `--STRING_LITERAL -> "annotation array initialization" [1317:64]
14376 | | | | |--COMMA -> , [1317:97]
14377 | | | | |--EXPR -> EXPR [1318:16]
14378 | | | | | `--NUM_INT -> 14 [1318:16]
14379 | | | | |--COMMA -> , [1318:18]
14380 | | | | `--EXPR -> EXPR [1318:20]
14381 | | | | `--STRING_LITERAL -> "16, 28, 30" [1318:20]
14382 | | | `--RPAREN -> ) [1318:32]
14383 | | |--COMMA -> , [1318:33]
14384 | | |--EXPR -> EXPR [1319:22]
14385 | | | `--PLUS -> + [1319:22]
14386 | | | |--STRING_LITERAL -> "129:9: " [1319:12]
14387 | | | `--METHOD_CALL -> ( [1319:39]
14388 | | | |--IDENT -> getCheckMessage [1319:24]
14389 | | | |--ELIST -> ELIST [1319:40]
14390 | | | | |--EXPR -> EXPR [1319:40]
14391 | | | | | `--IDENT -> MSG_ERROR_MULTI [1319:40]
14392 | | | | |--COMMA -> , [1319:55]
14393 | | | | |--EXPR -> EXPR [1319:57]
14394 | | | | | `--STRING_LITERAL -> "annotation array initialization rcurly" [1319:57]
14395 | | | | |--COMMA -> , [1319:97]
14396 | | | | |--EXPR -> EXPR [1320:16]
14397 | | | | | `--NUM_INT -> 8 [1320:16]
14398 | | | | |--COMMA -> , [1320:17]
14399 | | | | `--EXPR -> EXPR [1320:19]
14400 | | | | `--STRING_LITERAL -> "12, 16" [1320:19]
14401 | | | `--RPAREN -> ) [1320:27]
14402 | | |--COMMA -> , [1320:28]
14403 | | |--EXPR -> EXPR [1321:23]
14404 | | | `--PLUS -> + [1321:23]
14405 | | | |--STRING_LITERAL -> "131:13: " [1321:12]
14406 | | | `--METHOD_CALL -> ( [1321:40]
14407 | | | |--IDENT -> getCheckMessage [1321:25]
14408 | | | |--ELIST -> ELIST [1321:41]
14409 | | | | |--EXPR -> EXPR [1321:41]
14410 | | | | | `--IDENT -> MSG_CHILD_ERROR [1321:41]
14411 | | | | |--COMMA -> , [1321:56]
14412 | | | | |--EXPR -> EXPR [1321:58]
14413 | | | | | `--STRING_LITERAL -> "annotation array initialization" [1321:58]
14414 | | | | |--COMMA -> , [1321:91]
14415 | | | | |--EXPR -> EXPR [1322:16]
14416 | | | | | `--NUM_INT -> 12 [1322:16]
14417 | | | | |--COMMA -> , [1322:18]
14418 | | | | `--EXPR -> EXPR [1322:20]
14419 | | | | `--NUM_INT -> 16 [1322:20]
14420 | | | `--RPAREN -> ) [1322:22]
14421 | | |--COMMA -> , [1322:23]
14422 | | `--RCURLY -> } [1323:8]
14423 | |--SEMI -> ; [1323:9]
14424 | |--EXPR -> EXPR [1326:14]
14425 | | `--METHOD_CALL -> ( [1326:14]
14426 | | |--SINGLE_LINE_COMMENT -> // [1325:8]
14427 | | | `--COMMENT_CONTENT -> Test input for this test case is not checked due to issue #693.\n [1325:10]
14428 | | |--IDENT -> verify [1326:8]
14429 | | |--ELIST -> ELIST [1326:15]
14430 | | | |--EXPR -> EXPR [1326:15]
14431 | | | | `--IDENT -> checkConfig [1326:15]
14432 | | | |--COMMA -> , [1326:26]
14433 | | | |--EXPR -> EXPR [1326:28]
14434 | | | | `--IDENT -> fileName [1326:28]
14435 | | | |--COMMA -> , [1326:36]
14436 | | | `--EXPR -> EXPR [1326:38]
14437 | | | `--IDENT -> expected [1326:38]
14438 | | `--RPAREN -> ) [1326:46]
14439 | |--SEMI -> ; [1326:47]
14440 | `--RCURLY -> } [1327:4]
14441 |--METHOD_DEF -> METHOD_DEF [1329:4]
14442 | |--MODIFIERS -> MODIFIERS [1329:4]
14443 | | |--ANNOTATION -> ANNOTATION [1329:4]
14444 | | | |--AT -> @ [1329:4]
14445 | | | `--IDENT -> Test [1329:5]
14446 | | `--LITERAL_PUBLIC -> public [1330:4]
14447 | |--TYPE -> TYPE [1330:11]
14448 | | `--LITERAL_VOID -> void [1330:11]
14449 | |--IDENT -> testValidTryWithChecker [1330:16]
14450 | |--LPAREN -> ( [1330:39]
14451 | |--PARAMETERS -> PARAMETERS [1330:40]
14452 | |--RPAREN -> ) [1330:40]
14453 | |--LITERAL_THROWS -> throws [1331:12]
14454 | | `--IDENT -> Exception [1331:19]
14455 | `--SLIST -> { [1331:29]
14456 | |--VARIABLE_DEF -> VARIABLE_DEF [1332:8]
14457 | | |--MODIFIERS -> MODIFIERS [1332:8]
14458 | | | `--FINAL -> final [1332:8]
14459 | | |--TYPE -> TYPE [1332:14]
14460 | | | `--IDENT -> DefaultConfiguration [1332:14]
14461 | | |--IDENT -> checkConfig [1332:35]
14462 | | `--ASSIGN -> = [1332:47]
14463 | | `--EXPR -> EXPR [1332:67]
14464 | | `--METHOD_CALL -> ( [1332:67]
14465 | | |--IDENT -> createModuleConfig [1332:49]
14466 | | |--ELIST -> ELIST [1332:84]
14467 | | | `--EXPR -> EXPR [1332:84]
14468 | | | `--DOT -> . [1332:84]
14469 | | | |--IDENT -> IndentationCheck [1332:68]
14470 | | | `--LITERAL_CLASS -> class [1332:85]
14471 | | `--RPAREN -> ) [1332:90]
14472 | |--SEMI -> ; [1332:91]
14473 | |--EXPR -> EXPR [1334:32]
14474 | | `--METHOD_CALL -> ( [1334:32]
14475 | | |--DOT -> . [1334:19]
14476 | | | |--IDENT -> checkConfig [1334:8]
14477 | | | `--IDENT -> addAttribute [1334:20]
14478 | | |--ELIST -> ELIST [1334:33]
14479 | | | |--EXPR -> EXPR [1334:33]
14480 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1334:33]
14481 | | | |--COMMA -> , [1334:50]
14482 | | | `--EXPR -> EXPR [1334:52]
14483 | | | `--STRING_LITERAL -> "4" [1334:52]
14484 | | `--RPAREN -> ) [1334:55]
14485 | |--SEMI -> ; [1334:56]
14486 | |--EXPR -> EXPR [1335:32]
14487 | | `--METHOD_CALL -> ( [1335:32]
14488 | | |--DOT -> . [1335:19]
14489 | | | |--IDENT -> checkConfig [1335:8]
14490 | | | `--IDENT -> addAttribute [1335:20]
14491 | | |--ELIST -> ELIST [1335:33]
14492 | | | |--EXPR -> EXPR [1335:33]
14493 | | | | `--STRING_LITERAL -> "basicOffset" [1335:33]
14494 | | | |--COMMA -> , [1335:46]
14495 | | | `--EXPR -> EXPR [1335:48]
14496 | | | `--STRING_LITERAL -> "4" [1335:48]
14497 | | `--RPAREN -> ) [1335:51]
14498 | |--SEMI -> ; [1335:52]
14499 | |--EXPR -> EXPR [1336:32]
14500 | | `--METHOD_CALL -> ( [1336:32]
14501 | | |--DOT -> . [1336:19]
14502 | | | |--IDENT -> checkConfig [1336:8]
14503 | | | `--IDENT -> addAttribute [1336:20]
14504 | | |--ELIST -> ELIST [1336:33]
14505 | | | |--EXPR -> EXPR [1336:33]
14506 | | | | `--STRING_LITERAL -> "braceAdjustment" [1336:33]
14507 | | | |--COMMA -> , [1336:50]
14508 | | | `--EXPR -> EXPR [1336:52]
14509 | | | `--STRING_LITERAL -> "0" [1336:52]
14510 | | `--RPAREN -> ) [1336:55]
14511 | |--SEMI -> ; [1336:56]
14512 | |--EXPR -> EXPR [1337:32]
14513 | | `--METHOD_CALL -> ( [1337:32]
14514 | | |--DOT -> . [1337:19]
14515 | | | |--IDENT -> checkConfig [1337:8]
14516 | | | `--IDENT -> addAttribute [1337:20]
14517 | | |--ELIST -> ELIST [1337:33]
14518 | | | |--EXPR -> EXPR [1337:33]
14519 | | | | `--STRING_LITERAL -> "caseIndent" [1337:33]
14520 | | | |--COMMA -> , [1337:45]
14521 | | | `--EXPR -> EXPR [1337:47]
14522 | | | `--STRING_LITERAL -> "4" [1337:47]
14523 | | `--RPAREN -> ) [1337:50]
14524 | |--SEMI -> ; [1337:51]
14525 | |--EXPR -> EXPR [1338:32]
14526 | | `--METHOD_CALL -> ( [1338:32]
14527 | | |--DOT -> . [1338:19]
14528 | | | |--IDENT -> checkConfig [1338:8]
14529 | | | `--IDENT -> addAttribute [1338:20]
14530 | | |--ELIST -> ELIST [1338:33]
14531 | | | |--EXPR -> EXPR [1338:33]
14532 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1338:33]
14533 | | | |--COMMA -> , [1338:55]
14534 | | | `--EXPR -> EXPR [1338:57]
14535 | | | `--STRING_LITERAL -> "false" [1338:57]
14536 | | `--RPAREN -> ) [1338:64]
14537 | |--SEMI -> ; [1338:65]
14538 | |--EXPR -> EXPR [1339:32]
14539 | | `--METHOD_CALL -> ( [1339:32]
14540 | | |--DOT -> . [1339:19]
14541 | | | |--IDENT -> checkConfig [1339:8]
14542 | | | `--IDENT -> addAttribute [1339:20]
14543 | | |--ELIST -> ELIST [1339:33]
14544 | | | |--EXPR -> EXPR [1339:33]
14545 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1339:33]
14546 | | | |--COMMA -> , [1339:58]
14547 | | | `--EXPR -> EXPR [1339:60]
14548 | | | `--STRING_LITERAL -> "4" [1339:60]
14549 | | `--RPAREN -> ) [1339:63]
14550 | |--SEMI -> ; [1339:64]
14551 | |--EXPR -> EXPR [1340:32]
14552 | | `--METHOD_CALL -> ( [1340:32]
14553 | | |--DOT -> . [1340:19]
14554 | | | |--IDENT -> checkConfig [1340:8]
14555 | | | `--IDENT -> addAttribute [1340:20]
14556 | | |--ELIST -> ELIST [1340:33]
14557 | | | |--EXPR -> EXPR [1340:33]
14558 | | | | `--STRING_LITERAL -> "tabWidth" [1340:33]
14559 | | | |--COMMA -> , [1340:43]
14560 | | | `--EXPR -> EXPR [1340:45]
14561 | | | `--STRING_LITERAL -> "4" [1340:45]
14562 | | `--RPAREN -> ) [1340:48]
14563 | |--SEMI -> ; [1340:49]
14564 | |--EXPR -> EXPR [1341:32]
14565 | | `--METHOD_CALL -> ( [1341:32]
14566 | | |--DOT -> . [1341:19]
14567 | | | |--IDENT -> checkConfig [1341:8]
14568 | | | `--IDENT -> addAttribute [1341:20]
14569 | | |--ELIST -> ELIST [1341:33]
14570 | | | |--EXPR -> EXPR [1341:33]
14571 | | | | `--STRING_LITERAL -> "throwsIndent" [1341:33]
14572 | | | |--COMMA -> , [1341:47]
14573 | | | `--EXPR -> EXPR [1341:49]
14574 | | | `--STRING_LITERAL -> "4" [1341:49]
14575 | | `--RPAREN -> ) [1341:52]
14576 | |--SEMI -> ; [1341:53]
14577 | |--VARIABLE_DEF -> VARIABLE_DEF [1342:8]
14578 | | |--MODIFIERS -> MODIFIERS [1342:8]
14579 | | | `--FINAL -> final [1342:8]
14580 | | |--TYPE -> TYPE [1342:14]
14581 | | | `--IDENT -> String [1342:14]
14582 | | |--IDENT -> fileName [1342:21]
14583 | | `--ASSIGN -> = [1342:30]
14584 | | `--EXPR -> EXPR [1342:39]
14585 | | `--METHOD_CALL -> ( [1342:39]
14586 | | |--IDENT -> getPath [1342:32]
14587 | | |--ELIST -> ELIST [1342:40]
14588 | | | `--EXPR -> EXPR [1342:40]
14589 | | | `--STRING_LITERAL -> "InputIndentationValidTryIndent.java" [1342:40]
14590 | | `--RPAREN -> ) [1342:77]
14591 | |--SEMI -> ; [1342:78]
14592 | |--VARIABLE_DEF -> VARIABLE_DEF [1343:8]
14593 | | |--MODIFIERS -> MODIFIERS [1343:8]
14594 | | | `--FINAL -> final [1343:8]
14595 | | |--TYPE -> TYPE [1343:20]
14596 | | | `--ARRAY_DECLARATOR -> [ [1343:20]
14597 | | | |--IDENT -> String [1343:14]
14598 | | | `--RBRACK -> ] [1343:21]
14599 | | |--IDENT -> expected [1343:23]
14600 | | `--ASSIGN -> = [1343:32]
14601 | | `--EXPR -> EXPR [1343:44]
14602 | | `--DOT -> . [1343:44]
14603 | | |--IDENT -> CommonUtil [1343:34]
14604 | | `--IDENT -> EMPTY_STRING_ARRAY [1343:45]
14605 | |--SEMI -> ; [1343:63]
14606 | |--EXPR -> EXPR [1344:19]
14607 | | `--METHOD_CALL -> ( [1344:19]
14608 | | |--IDENT -> verifyWarns [1344:8]
14609 | | |--ELIST -> ELIST [1344:20]
14610 | | | |--EXPR -> EXPR [1344:20]
14611 | | | | `--IDENT -> checkConfig [1344:20]
14612 | | | |--COMMA -> , [1344:31]
14613 | | | |--EXPR -> EXPR [1344:33]
14614 | | | | `--IDENT -> fileName [1344:33]
14615 | | | |--COMMA -> , [1344:41]
14616 | | | `--EXPR -> EXPR [1344:43]
14617 | | | `--IDENT -> expected [1344:43]
14618 | | `--RPAREN -> ) [1344:51]
14619 | |--SEMI -> ; [1344:52]
14620 | `--RCURLY -> } [1345:4]
14621 |--METHOD_DEF -> METHOD_DEF [1347:4]
14622 | |--MODIFIERS -> MODIFIERS [1347:4]
14623 | | |--ANNOTATION -> ANNOTATION [1347:4]
14624 | | | |--AT -> @ [1347:4]
14625 | | | `--IDENT -> Test [1347:5]
14626 | | `--LITERAL_PUBLIC -> public [1348:4]
14627 | |--TYPE -> TYPE [1348:11]
14628 | | `--LITERAL_VOID -> void [1348:11]
14629 | |--IDENT -> testInvalidTryWithChecker [1348:16]
14630 | |--LPAREN -> ( [1348:41]
14631 | |--PARAMETERS -> PARAMETERS [1348:42]
14632 | |--RPAREN -> ) [1348:42]
14633 | |--LITERAL_THROWS -> throws [1349:12]
14634 | | `--IDENT -> Exception [1349:19]
14635 | `--SLIST -> { [1349:29]
14636 | |--VARIABLE_DEF -> VARIABLE_DEF [1350:8]
14637 | | |--MODIFIERS -> MODIFIERS [1350:8]
14638 | | | `--FINAL -> final [1350:8]
14639 | | |--TYPE -> TYPE [1350:14]
14640 | | | `--IDENT -> DefaultConfiguration [1350:14]
14641 | | |--IDENT -> checkConfig [1350:35]
14642 | | `--ASSIGN -> = [1350:47]
14643 | | `--EXPR -> EXPR [1350:67]
14644 | | `--METHOD_CALL -> ( [1350:67]
14645 | | |--IDENT -> createModuleConfig [1350:49]
14646 | | |--ELIST -> ELIST [1350:84]
14647 | | | `--EXPR -> EXPR [1350:84]
14648 | | | `--DOT -> . [1350:84]
14649 | | | |--IDENT -> IndentationCheck [1350:68]
14650 | | | `--LITERAL_CLASS -> class [1350:85]
14651 | | `--RPAREN -> ) [1350:90]
14652 | |--SEMI -> ; [1350:91]
14653 | |--EXPR -> EXPR [1352:32]
14654 | | `--METHOD_CALL -> ( [1352:32]
14655 | | |--DOT -> . [1352:19]
14656 | | | |--IDENT -> checkConfig [1352:8]
14657 | | | `--IDENT -> addAttribute [1352:20]
14658 | | |--ELIST -> ELIST [1352:33]
14659 | | | |--EXPR -> EXPR [1352:33]
14660 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1352:33]
14661 | | | |--COMMA -> , [1352:50]
14662 | | | `--EXPR -> EXPR [1352:52]
14663 | | | `--STRING_LITERAL -> "4" [1352:52]
14664 | | `--RPAREN -> ) [1352:55]
14665 | |--SEMI -> ; [1352:56]
14666 | |--EXPR -> EXPR [1353:32]
14667 | | `--METHOD_CALL -> ( [1353:32]
14668 | | |--DOT -> . [1353:19]
14669 | | | |--IDENT -> checkConfig [1353:8]
14670 | | | `--IDENT -> addAttribute [1353:20]
14671 | | |--ELIST -> ELIST [1353:33]
14672 | | | |--EXPR -> EXPR [1353:33]
14673 | | | | `--STRING_LITERAL -> "basicOffset" [1353:33]
14674 | | | |--COMMA -> , [1353:46]
14675 | | | `--EXPR -> EXPR [1353:48]
14676 | | | `--STRING_LITERAL -> "4" [1353:48]
14677 | | `--RPAREN -> ) [1353:51]
14678 | |--SEMI -> ; [1353:52]
14679 | |--EXPR -> EXPR [1354:32]
14680 | | `--METHOD_CALL -> ( [1354:32]
14681 | | |--DOT -> . [1354:19]
14682 | | | |--IDENT -> checkConfig [1354:8]
14683 | | | `--IDENT -> addAttribute [1354:20]
14684 | | |--ELIST -> ELIST [1354:33]
14685 | | | |--EXPR -> EXPR [1354:33]
14686 | | | | `--STRING_LITERAL -> "braceAdjustment" [1354:33]
14687 | | | |--COMMA -> , [1354:50]
14688 | | | `--EXPR -> EXPR [1354:52]
14689 | | | `--STRING_LITERAL -> "0" [1354:52]
14690 | | `--RPAREN -> ) [1354:55]
14691 | |--SEMI -> ; [1354:56]
14692 | |--EXPR -> EXPR [1355:32]
14693 | | `--METHOD_CALL -> ( [1355:32]
14694 | | |--DOT -> . [1355:19]
14695 | | | |--IDENT -> checkConfig [1355:8]
14696 | | | `--IDENT -> addAttribute [1355:20]
14697 | | |--ELIST -> ELIST [1355:33]
14698 | | | |--EXPR -> EXPR [1355:33]
14699 | | | | `--STRING_LITERAL -> "caseIndent" [1355:33]
14700 | | | |--COMMA -> , [1355:45]
14701 | | | `--EXPR -> EXPR [1355:47]
14702 | | | `--STRING_LITERAL -> "4" [1355:47]
14703 | | `--RPAREN -> ) [1355:50]
14704 | |--SEMI -> ; [1355:51]
14705 | |--EXPR -> EXPR [1356:32]
14706 | | `--METHOD_CALL -> ( [1356:32]
14707 | | |--DOT -> . [1356:19]
14708 | | | |--IDENT -> checkConfig [1356:8]
14709 | | | `--IDENT -> addAttribute [1356:20]
14710 | | |--ELIST -> ELIST [1356:33]
14711 | | | |--EXPR -> EXPR [1356:33]
14712 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1356:33]
14713 | | | |--COMMA -> , [1356:55]
14714 | | | `--EXPR -> EXPR [1356:57]
14715 | | | `--STRING_LITERAL -> "false" [1356:57]
14716 | | `--RPAREN -> ) [1356:64]
14717 | |--SEMI -> ; [1356:65]
14718 | |--EXPR -> EXPR [1357:32]
14719 | | `--METHOD_CALL -> ( [1357:32]
14720 | | |--DOT -> . [1357:19]
14721 | | | |--IDENT -> checkConfig [1357:8]
14722 | | | `--IDENT -> addAttribute [1357:20]
14723 | | |--ELIST -> ELIST [1357:33]
14724 | | | |--EXPR -> EXPR [1357:33]
14725 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1357:33]
14726 | | | |--COMMA -> , [1357:58]
14727 | | | `--EXPR -> EXPR [1357:60]
14728 | | | `--STRING_LITERAL -> "4" [1357:60]
14729 | | `--RPAREN -> ) [1357:63]
14730 | |--SEMI -> ; [1357:64]
14731 | |--EXPR -> EXPR [1358:32]
14732 | | `--METHOD_CALL -> ( [1358:32]
14733 | | |--DOT -> . [1358:19]
14734 | | | |--IDENT -> checkConfig [1358:8]
14735 | | | `--IDENT -> addAttribute [1358:20]
14736 | | |--ELIST -> ELIST [1358:33]
14737 | | | |--EXPR -> EXPR [1358:33]
14738 | | | | `--STRING_LITERAL -> "tabWidth" [1358:33]
14739 | | | |--COMMA -> , [1358:43]
14740 | | | `--EXPR -> EXPR [1358:45]
14741 | | | `--STRING_LITERAL -> "4" [1358:45]
14742 | | `--RPAREN -> ) [1358:48]
14743 | |--SEMI -> ; [1358:49]
14744 | |--EXPR -> EXPR [1359:32]
14745 | | `--METHOD_CALL -> ( [1359:32]
14746 | | |--DOT -> . [1359:19]
14747 | | | |--IDENT -> checkConfig [1359:8]
14748 | | | `--IDENT -> addAttribute [1359:20]
14749 | | |--ELIST -> ELIST [1359:33]
14750 | | | |--EXPR -> EXPR [1359:33]
14751 | | | | `--STRING_LITERAL -> "throwsIndent" [1359:33]
14752 | | | |--COMMA -> , [1359:47]
14753 | | | `--EXPR -> EXPR [1359:49]
14754 | | | `--STRING_LITERAL -> "4" [1359:49]
14755 | | `--RPAREN -> ) [1359:52]
14756 | |--SEMI -> ; [1359:53]
14757 | |--VARIABLE_DEF -> VARIABLE_DEF [1360:8]
14758 | | |--MODIFIERS -> MODIFIERS [1360:8]
14759 | | | `--FINAL -> final [1360:8]
14760 | | |--TYPE -> TYPE [1360:14]
14761 | | | `--IDENT -> String [1360:14]
14762 | | |--IDENT -> fileName [1360:21]
14763 | | `--ASSIGN -> = [1360:30]
14764 | | `--EXPR -> EXPR [1360:39]
14765 | | `--METHOD_CALL -> ( [1360:39]
14766 | | |--IDENT -> getPath [1360:32]
14767 | | |--ELIST -> ELIST [1360:40]
14768 | | | `--EXPR -> EXPR [1360:40]
14769 | | | `--STRING_LITERAL -> "InputIndentationInvalidTryIndent.java" [1360:40]
14770 | | `--RPAREN -> ) [1360:79]
14771 | |--SEMI -> ; [1360:80]
14772 | |--VARIABLE_DEF -> VARIABLE_DEF [1361:8]
14773 | | |--MODIFIERS -> MODIFIERS [1361:8]
14774 | | | `--FINAL -> final [1361:8]
14775 | | |--TYPE -> TYPE [1361:20]
14776 | | | `--ARRAY_DECLARATOR -> [ [1361:20]
14777 | | | |--IDENT -> String [1361:14]
14778 | | | `--RBRACK -> ] [1361:21]
14779 | | |--IDENT -> expected [1361:23]
14780 | | `--ASSIGN -> = [1361:32]
14781 | | `--ARRAY_INIT -> { [1361:34]
14782 | | |--EXPR -> EXPR [1362:22]
14783 | | | `--PLUS -> + [1362:22]
14784 | | | |--STRING_LITERAL -> "25:10: " [1362:12]
14785 | | | `--METHOD_CALL -> ( [1362:39]
14786 | | | |--IDENT -> getCheckMessage [1362:24]
14787 | | | |--ELIST -> ELIST [1362:40]
14788 | | | | |--EXPR -> EXPR [1362:40]
14789 | | | | | `--IDENT -> MSG_ERROR [1362:40]
14790 | | | | |--COMMA -> , [1362:49]
14791 | | | | |--EXPR -> EXPR [1362:51]
14792 | | | | | `--STRING_LITERAL -> "try" [1362:51]
14793 | | | | |--COMMA -> , [1362:56]
14794 | | | | |--EXPR -> EXPR [1362:58]
14795 | | | | | `--NUM_INT -> 9 [1362:58]
14796 | | | | |--COMMA -> , [1362:59]
14797 | | | | `--EXPR -> EXPR [1362:61]
14798 | | | | `--NUM_INT -> 8 [1362:61]
14799 | | | `--RPAREN -> ) [1362:62]
14800 | | |--COMMA -> , [1362:63]
14801 | | |--EXPR -> EXPR [1363:21]
14802 | | | `--PLUS -> + [1363:21]
14803 | | | |--STRING_LITERAL -> "26:8: " [1363:12]
14804 | | | `--METHOD_CALL -> ( [1363:38]
14805 | | | |--IDENT -> getCheckMessage [1363:23]
14806 | | | |--ELIST -> ELIST [1363:39]
14807 | | | | |--EXPR -> EXPR [1363:39]
14808 | | | | | `--IDENT -> MSG_ERROR [1363:39]
14809 | | | | |--COMMA -> , [1363:48]
14810 | | | | |--EXPR -> EXPR [1363:50]
14811 | | | | | `--STRING_LITERAL -> "try rcurly" [1363:50]
14812 | | | | |--COMMA -> , [1363:62]
14813 | | | | |--EXPR -> EXPR [1363:64]
14814 | | | | | `--NUM_INT -> 7 [1363:64]
14815 | | | | |--COMMA -> , [1363:65]
14816 | | | | `--EXPR -> EXPR [1363:67]
14817 | | | | `--NUM_INT -> 8 [1363:67]
14818 | | | `--RPAREN -> ) [1363:68]
14819 | | |--COMMA -> , [1363:69]
14820 | | |--EXPR -> EXPR [1364:21]
14821 | | | `--PLUS -> + [1364:21]
14822 | | | |--STRING_LITERAL -> "28:8: " [1364:12]
14823 | | | `--METHOD_CALL -> ( [1364:38]
14824 | | | |--IDENT -> getCheckMessage [1364:23]
14825 | | | |--ELIST -> ELIST [1364:39]
14826 | | | | |--EXPR -> EXPR [1364:39]
14827 | | | | | `--IDENT -> MSG_ERROR [1364:39]
14828 | | | | |--COMMA -> , [1364:48]
14829 | | | | |--EXPR -> EXPR [1364:50]
14830 | | | | | `--STRING_LITERAL -> "catch rcurly" [1364:50]
14831 | | | | |--COMMA -> , [1364:64]
14832 | | | | |--EXPR -> EXPR [1364:66]
14833 | | | | | `--NUM_INT -> 7 [1364:66]
14834 | | | | |--COMMA -> , [1364:67]
14835 | | | | `--EXPR -> EXPR [1364:69]
14836 | | | | `--NUM_INT -> 8 [1364:69]
14837 | | | `--RPAREN -> ) [1364:70]
14838 | | |--COMMA -> , [1364:71]
14839 | | |--EXPR -> EXPR [1365:21]
14840 | | | `--PLUS -> + [1365:21]
14841 | | | |--STRING_LITERAL -> "30:5: " [1365:12]
14842 | | | `--METHOD_CALL -> ( [1365:38]
14843 | | | |--IDENT -> getCheckMessage [1365:23]
14844 | | | |--ELIST -> ELIST [1365:39]
14845 | | | | |--EXPR -> EXPR [1365:39]
14846 | | | | | `--IDENT -> MSG_ERROR [1365:39]
14847 | | | | |--COMMA -> , [1365:48]
14848 | | | | |--EXPR -> EXPR [1365:50]
14849 | | | | | `--STRING_LITERAL -> "try" [1365:50]
14850 | | | | |--COMMA -> , [1365:55]
14851 | | | | |--EXPR -> EXPR [1365:57]
14852 | | | | | `--NUM_INT -> 4 [1365:57]
14853 | | | | |--COMMA -> , [1365:58]
14854 | | | | `--EXPR -> EXPR [1365:60]
14855 | | | | `--NUM_INT -> 8 [1365:60]
14856 | | | `--RPAREN -> ) [1365:61]
14857 | | |--COMMA -> , [1365:62]
14858 | | |--EXPR -> EXPR [1366:21]
14859 | | | `--PLUS -> + [1366:21]
14860 | | | |--STRING_LITERAL -> "31:9: " [1366:12]
14861 | | | `--METHOD_CALL -> ( [1366:38]
14862 | | | |--IDENT -> getCheckMessage [1366:23]
14863 | | | |--ELIST -> ELIST [1366:39]
14864 | | | | |--EXPR -> EXPR [1366:39]
14865 | | | | | `--IDENT -> MSG_CHILD_ERROR [1366:39]
14866 | | | | |--COMMA -> , [1366:54]
14867 | | | | |--EXPR -> EXPR [1366:56]
14868 | | | | | `--STRING_LITERAL -> "try" [1366:56]
14869 | | | | |--COMMA -> , [1366:61]
14870 | | | | |--EXPR -> EXPR [1366:63]
14871 | | | | | `--NUM_INT -> 8 [1366:63]
14872 | | | | |--COMMA -> , [1366:64]
14873 | | | | `--EXPR -> EXPR [1366:66]
14874 | | | | `--NUM_INT -> 12 [1366:66]
14875 | | | `--RPAREN -> ) [1366:68]
14876 | | |--COMMA -> , [1366:69]
14877 | | |--EXPR -> EXPR [1367:21]
14878 | | | `--PLUS -> + [1367:21]
14879 | | | |--STRING_LITERAL -> "32:5: " [1367:12]
14880 | | | `--METHOD_CALL -> ( [1367:38]
14881 | | | |--IDENT -> getCheckMessage [1367:23]
14882 | | | |--ELIST -> ELIST [1367:39]
14883 | | | | |--EXPR -> EXPR [1367:39]
14884 | | | | | `--IDENT -> MSG_ERROR [1367:39]
14885 | | | | |--COMMA -> , [1367:48]
14886 | | | | |--EXPR -> EXPR [1367:50]
14887 | | | | | `--STRING_LITERAL -> "try rcurly" [1367:50]
14888 | | | | |--COMMA -> , [1367:62]
14889 | | | | |--EXPR -> EXPR [1367:64]
14890 | | | | | `--NUM_INT -> 4 [1367:64]
14891 | | | | |--COMMA -> , [1367:65]
14892 | | | | `--EXPR -> EXPR [1367:67]
14893 | | | | `--NUM_INT -> 8 [1367:67]
14894 | | | `--RPAREN -> ) [1367:68]
14895 | | |--COMMA -> , [1367:69]
14896 | | |--EXPR -> EXPR [1368:21]
14897 | | | `--PLUS -> + [1368:21]
14898 | | | |--STRING_LITERAL -> "33:9: " [1368:12]
14899 | | | `--METHOD_CALL -> ( [1368:38]
14900 | | | |--IDENT -> getCheckMessage [1368:23]
14901 | | | |--ELIST -> ELIST [1368:39]
14902 | | | | |--EXPR -> EXPR [1368:39]
14903 | | | | | `--IDENT -> MSG_CHILD_ERROR [1368:39]
14904 | | | | |--COMMA -> , [1368:54]
14905 | | | | |--EXPR -> EXPR [1368:56]
14906 | | | | | `--STRING_LITERAL -> "finally" [1368:56]
14907 | | | | |--COMMA -> , [1368:65]
14908 | | | | |--EXPR -> EXPR [1368:67]
14909 | | | | | `--NUM_INT -> 8 [1368:67]
14910 | | | | |--COMMA -> , [1368:68]
14911 | | | | `--EXPR -> EXPR [1368:70]
14912 | | | | `--NUM_INT -> 12 [1368:70]
14913 | | | `--RPAREN -> ) [1368:72]
14914 | | |--COMMA -> , [1368:73]
14915 | | |--EXPR -> EXPR [1369:21]
14916 | | | `--PLUS -> + [1369:21]
14917 | | | |--STRING_LITERAL -> "38:9: " [1369:12]
14918 | | | `--METHOD_CALL -> ( [1369:38]
14919 | | | |--IDENT -> getCheckMessage [1369:23]
14920 | | | |--ELIST -> ELIST [1369:39]
14921 | | | | |--EXPR -> EXPR [1369:39]
14922 | | | | | `--IDENT -> MSG_CHILD_ERROR [1369:39]
14923 | | | | |--COMMA -> , [1369:54]
14924 | | | | |--EXPR -> EXPR [1369:56]
14925 | | | | | `--STRING_LITERAL -> "catch" [1369:56]
14926 | | | | |--COMMA -> , [1369:63]
14927 | | | | |--EXPR -> EXPR [1369:65]
14928 | | | | | `--NUM_INT -> 8 [1369:65]
14929 | | | | |--COMMA -> , [1369:66]
14930 | | | | `--EXPR -> EXPR [1369:68]
14931 | | | | `--NUM_INT -> 12 [1369:68]
14932 | | | `--RPAREN -> ) [1369:70]
14933 | | |--COMMA -> , [1369:71]
14934 | | |--EXPR -> EXPR [1370:22]
14935 | | | `--PLUS -> + [1370:22]
14936 | | | |--STRING_LITERAL -> "43:11: " [1370:12]
14937 | | | `--METHOD_CALL -> ( [1370:39]
14938 | | | |--IDENT -> getCheckMessage [1370:24]
14939 | | | |--ELIST -> ELIST [1370:40]
14940 | | | | |--EXPR -> EXPR [1370:40]
14941 | | | | | `--IDENT -> MSG_ERROR [1370:40]
14942 | | | | |--COMMA -> , [1370:49]
14943 | | | | |--EXPR -> EXPR [1370:51]
14944 | | | | | `--STRING_LITERAL -> "try rcurly" [1370:51]
14945 | | | | |--COMMA -> , [1370:63]
14946 | | | | |--EXPR -> EXPR [1370:65]
14947 | | | | | `--NUM_INT -> 10 [1370:65]
14948 | | | | |--COMMA -> , [1370:67]
14949 | | | | `--EXPR -> EXPR [1370:69]
14950 | | | | `--NUM_INT -> 8 [1370:69]
14951 | | | `--RPAREN -> ) [1370:70]
14952 | | |--COMMA -> , [1370:71]
14953 | | |--EXPR -> EXPR [1371:21]
14954 | | | `--PLUS -> + [1371:21]
14955 | | | |--STRING_LITERAL -> "45:7: " [1371:12]
14956 | | | `--METHOD_CALL -> ( [1371:38]
14957 | | | |--IDENT -> getCheckMessage [1371:23]
14958 | | | |--ELIST -> ELIST [1371:39]
14959 | | | | |--EXPR -> EXPR [1371:39]
14960 | | | | | `--IDENT -> MSG_ERROR [1371:39]
14961 | | | | |--COMMA -> , [1371:48]
14962 | | | | |--EXPR -> EXPR [1371:50]
14963 | | | | | `--STRING_LITERAL -> "catch rcurly" [1371:50]
14964 | | | | |--COMMA -> , [1371:64]
14965 | | | | |--EXPR -> EXPR [1371:66]
14966 | | | | | `--NUM_INT -> 6 [1371:66]
14967 | | | | |--COMMA -> , [1371:67]
14968 | | | | `--EXPR -> EXPR [1371:69]
14969 | | | | `--NUM_INT -> 8 [1371:69]
14970 | | | `--RPAREN -> ) [1371:70]
14971 | | |--COMMA -> , [1371:71]
14972 | | |--EXPR -> EXPR [1372:21]
14973 | | | `--PLUS -> + [1372:21]
14974 | | | |--STRING_LITERAL -> "52:6: " [1372:12]
14975 | | | `--METHOD_CALL -> ( [1372:38]
14976 | | | |--IDENT -> getCheckMessage [1372:23]
14977 | | | |--ELIST -> ELIST [1372:39]
14978 | | | | |--EXPR -> EXPR [1372:39]
14979 | | | | | `--IDENT -> MSG_ERROR [1372:39]
14980 | | | | |--COMMA -> , [1372:48]
14981 | | | | |--EXPR -> EXPR [1372:50]
14982 | | | | | `--STRING_LITERAL -> "catch rcurly" [1372:50]
14983 | | | | |--COMMA -> , [1372:64]
14984 | | | | |--EXPR -> EXPR [1372:66]
14985 | | | | | `--NUM_INT -> 5 [1372:66]
14986 | | | | |--COMMA -> , [1372:67]
14987 | | | | `--EXPR -> EXPR [1372:69]
14988 | | | | `--NUM_INT -> 8 [1372:69]
14989 | | | `--RPAREN -> ) [1372:70]
14990 | | |--COMMA -> , [1372:71]
14991 | | |--EXPR -> EXPR [1373:22]
14992 | | | `--PLUS -> + [1373:22]
14993 | | | |--STRING_LITERAL -> "59:11: " [1373:12]
14994 | | | `--METHOD_CALL -> ( [1373:39]
14995 | | | |--IDENT -> getCheckMessage [1373:24]
14996 | | | |--ELIST -> ELIST [1373:40]
14997 | | | | |--EXPR -> EXPR [1373:40]
14998 | | | | | `--IDENT -> MSG_CHILD_ERROR [1373:40]
14999 | | | | |--COMMA -> , [1373:55]
15000 | | | | |--EXPR -> EXPR [1373:57]
15001 | | | | | `--STRING_LITERAL -> "catch" [1373:57]
15002 | | | | |--COMMA -> , [1373:64]
15003 | | | | |--EXPR -> EXPR [1373:66]
15004 | | | | | `--NUM_INT -> 10 [1373:66]
15005 | | | | |--COMMA -> , [1373:68]
15006 | | | | `--EXPR -> EXPR [1373:70]
15007 | | | | `--NUM_INT -> 12 [1373:70]
15008 | | | `--RPAREN -> ) [1373:72]
15009 | | |--COMMA -> , [1373:73]
15010 | | |--EXPR -> EXPR [1374:22]
15011 | | | `--PLUS -> + [1374:22]
15012 | | | |--STRING_LITERAL -> "60:15: " [1374:12]
15013 | | | `--METHOD_CALL -> ( [1374:39]
15014 | | | |--IDENT -> getCheckMessage [1374:24]
15015 | | | |--ELIST -> ELIST [1374:40]
15016 | | | | |--EXPR -> EXPR [1374:40]
15017 | | | | | `--IDENT -> MSG_CHILD_ERROR [1374:40]
15018 | | | | |--COMMA -> , [1374:55]
15019 | | | | |--EXPR -> EXPR [1374:57]
15020 | | | | | `--STRING_LITERAL -> "catch" [1374:57]
15021 | | | | |--COMMA -> , [1374:64]
15022 | | | | |--EXPR -> EXPR [1374:66]
15023 | | | | | `--NUM_INT -> 14 [1374:66]
15024 | | | | |--COMMA -> , [1374:68]
15025 | | | | `--EXPR -> EXPR [1374:70]
15026 | | | | `--NUM_INT -> 12 [1374:70]
15027 | | | `--RPAREN -> ) [1374:72]
15028 | | |--COMMA -> , [1374:73]
15029 | | |--EXPR -> EXPR [1375:22]
15030 | | | `--PLUS -> + [1375:22]
15031 | | | |--STRING_LITERAL -> "61:11: " [1375:12]
15032 | | | `--METHOD_CALL -> ( [1375:39]
15033 | | | |--IDENT -> getCheckMessage [1375:24]
15034 | | | |--ELIST -> ELIST [1375:40]
15035 | | | | |--EXPR -> EXPR [1375:40]
15036 | | | | | `--IDENT -> MSG_CHILD_ERROR [1375:40]
15037 | | | | |--COMMA -> , [1375:55]
15038 | | | | |--EXPR -> EXPR [1375:57]
15039 | | | | | `--STRING_LITERAL -> "catch" [1375:57]
15040 | | | | |--COMMA -> , [1375:64]
15041 | | | | |--EXPR -> EXPR [1375:66]
15042 | | | | | `--NUM_INT -> 10 [1375:66]
15043 | | | | |--COMMA -> , [1375:68]
15044 | | | | `--EXPR -> EXPR [1375:70]
15045 | | | | `--NUM_INT -> 12 [1375:70]
15046 | | | `--RPAREN -> ) [1375:72]
15047 | | |--COMMA -> , [1375:73]
15048 | | |--EXPR -> EXPR [1376:21]
15049 | | | `--PLUS -> + [1376:21]
15050 | | | |--STRING_LITERAL -> "63:7: " [1376:12]
15051 | | | `--METHOD_CALL -> ( [1376:38]
15052 | | | |--IDENT -> getCheckMessage [1376:23]
15053 | | | |--ELIST -> ELIST [1376:39]
15054 | | | | |--EXPR -> EXPR [1376:39]
15055 | | | | | `--IDENT -> MSG_ERROR [1376:39]
15056 | | | | |--COMMA -> , [1376:48]
15057 | | | | |--EXPR -> EXPR [1376:50]
15058 | | | | | `--STRING_LITERAL -> "catch" [1376:50]
15059 | | | | |--COMMA -> , [1376:57]
15060 | | | | |--EXPR -> EXPR [1376:59]
15061 | | | | | `--NUM_INT -> 6 [1376:59]
15062 | | | | |--COMMA -> , [1376:60]
15063 | | | | `--EXPR -> EXPR [1376:62]
15064 | | | | `--NUM_INT -> 8 [1376:62]
15065 | | | `--RPAREN -> ) [1376:63]
15066 | | |--COMMA -> , [1376:64]
15067 | | |--EXPR -> EXPR [1377:22]
15068 | | | `--PLUS -> + [1377:22]
15069 | | | |--STRING_LITERAL -> "70:11: " [1377:12]
15070 | | | `--METHOD_CALL -> ( [1377:39]
15071 | | | |--IDENT -> getCheckMessage [1377:24]
15072 | | | |--ELIST -> ELIST [1377:40]
15073 | | | | |--EXPR -> EXPR [1377:40]
15074 | | | | | `--IDENT -> MSG_ERROR [1377:40]
15075 | | | | |--COMMA -> , [1377:49]
15076 | | | | |--EXPR -> EXPR [1377:51]
15077 | | | | | `--STRING_LITERAL -> "try lcurly" [1377:51]
15078 | | | | |--COMMA -> , [1377:63]
15079 | | | | |--EXPR -> EXPR [1377:65]
15080 | | | | | `--NUM_INT -> 10 [1377:65]
15081 | | | | |--COMMA -> , [1377:67]
15082 | | | | `--EXPR -> EXPR [1377:69]
15083 | | | | `--NUM_INT -> 8 [1377:69]
15084 | | | `--RPAREN -> ) [1377:70]
15085 | | |--COMMA -> , [1377:71]
15086 | | |--EXPR -> EXPR [1378:22]
15087 | | | `--PLUS -> + [1378:22]
15088 | | | |--STRING_LITERAL -> "72:11: " [1378:12]
15089 | | | `--METHOD_CALL -> ( [1378:39]
15090 | | | |--IDENT -> getCheckMessage [1378:24]
15091 | | | |--ELIST -> ELIST [1378:40]
15092 | | | | |--EXPR -> EXPR [1378:40]
15093 | | | | | `--IDENT -> MSG_ERROR [1378:40]
15094 | | | | |--COMMA -> , [1378:49]
15095 | | | | |--EXPR -> EXPR [1378:51]
15096 | | | | | `--STRING_LITERAL -> "try rcurly" [1378:51]
15097 | | | | |--COMMA -> , [1378:63]
15098 | | | | |--EXPR -> EXPR [1378:65]
15099 | | | | | `--NUM_INT -> 10 [1378:65]
15100 | | | | |--COMMA -> , [1378:67]
15101 | | | | `--EXPR -> EXPR [1378:69]
15102 | | | | `--NUM_INT -> 8 [1378:69]
15103 | | | `--RPAREN -> ) [1378:70]
15104 | | |--COMMA -> , [1378:71]
15105 | | |--EXPR -> EXPR [1379:21]
15106 | | | `--PLUS -> + [1379:21]
15107 | | | |--STRING_LITERAL -> "74:7: " [1379:12]
15108 | | | `--METHOD_CALL -> ( [1379:38]
15109 | | | |--IDENT -> getCheckMessage [1379:23]
15110 | | | |--ELIST -> ELIST [1379:39]
15111 | | | | |--EXPR -> EXPR [1379:39]
15112 | | | | | `--IDENT -> MSG_ERROR [1379:39]
15113 | | | | |--COMMA -> , [1379:48]
15114 | | | | |--EXPR -> EXPR [1379:50]
15115 | | | | | `--STRING_LITERAL -> "catch lcurly" [1379:50]
15116 | | | | |--COMMA -> , [1379:64]
15117 | | | | |--EXPR -> EXPR [1379:66]
15118 | | | | | `--NUM_INT -> 6 [1379:66]
15119 | | | | |--COMMA -> , [1379:67]
15120 | | | | `--EXPR -> EXPR [1379:69]
15121 | | | | `--NUM_INT -> 8 [1379:69]
15122 | | | `--RPAREN -> ) [1379:70]
15123 | | |--COMMA -> , [1379:71]
15124 | | |--EXPR -> EXPR [1380:22]
15125 | | | `--PLUS -> + [1380:22]
15126 | | | |--STRING_LITERAL -> "77:11: " [1380:12]
15127 | | | `--METHOD_CALL -> ( [1380:39]
15128 | | | |--IDENT -> getCheckMessage [1380:24]
15129 | | | |--ELIST -> ELIST [1380:40]
15130 | | | | |--EXPR -> EXPR [1380:40]
15131 | | | | | `--IDENT -> MSG_ERROR [1380:40]
15132 | | | | |--COMMA -> , [1380:49]
15133 | | | | |--EXPR -> EXPR [1380:51]
15134 | | | | | `--STRING_LITERAL -> "catch rcurly" [1380:51]
15135 | | | | |--COMMA -> , [1380:65]
15136 | | | | |--EXPR -> EXPR [1380:67]
15137 | | | | | `--NUM_INT -> 10 [1380:67]
15138 | | | | |--COMMA -> , [1380:69]
15139 | | | | `--EXPR -> EXPR [1380:71]
15140 | | | | `--NUM_INT -> 8 [1380:71]
15141 | | | `--RPAREN -> ) [1380:72]
15142 | | |--COMMA -> , [1380:73]
15143 | | |--EXPR -> EXPR [1381:22]
15144 | | | `--PLUS -> + [1381:22]
15145 | | | |--STRING_LITERAL -> "80:11: " [1381:12]
15146 | | | `--METHOD_CALL -> ( [1381:39]
15147 | | | |--IDENT -> getCheckMessage [1381:24]
15148 | | | |--ELIST -> ELIST [1381:40]
15149 | | | | |--EXPR -> EXPR [1381:40]
15150 | | | | | `--IDENT -> MSG_CHILD_ERROR [1381:40]
15151 | | | | |--COMMA -> , [1381:55]
15152 | | | | |--EXPR -> EXPR [1381:57]
15153 | | | | | `--STRING_LITERAL -> "catch" [1381:57]
15154 | | | | |--COMMA -> , [1381:64]
15155 | | | | |--EXPR -> EXPR [1381:66]
15156 | | | | | `--NUM_INT -> 10 [1381:66]
15157 | | | | |--COMMA -> , [1381:68]
15158 | | | | `--EXPR -> EXPR [1381:70]
15159 | | | | `--NUM_INT -> 12 [1381:70]
15160 | | | `--RPAREN -> ) [1381:72]
15161 | | |--COMMA -> , [1381:73]
15162 | | |--EXPR -> EXPR [1382:21]
15163 | | | `--PLUS -> + [1382:21]
15164 | | | |--STRING_LITERAL -> "86:1: " [1382:12]
15165 | | | `--METHOD_CALL -> ( [1382:38]
15166 | | | |--IDENT -> getCheckMessage [1382:23]
15167 | | | |--ELIST -> ELIST [1382:39]
15168 | | | | |--EXPR -> EXPR [1382:39]
15169 | | | | | `--IDENT -> MSG_ERROR [1382:39]
15170 | | | | |--COMMA -> , [1382:48]
15171 | | | | |--EXPR -> EXPR [1382:50]
15172 | | | | | `--STRING_LITERAL -> "try" [1382:50]
15173 | | | | |--COMMA -> , [1382:55]
15174 | | | | |--EXPR -> EXPR [1382:57]
15175 | | | | | `--NUM_INT -> 0 [1382:57]
15176 | | | | |--COMMA -> , [1382:58]
15177 | | | | `--EXPR -> EXPR [1382:60]
15178 | | | | `--NUM_INT -> 8 [1382:60]
15179 | | | `--RPAREN -> ) [1382:61]
15180 | | |--COMMA -> , [1382:62]
15181 | | |--EXPR -> EXPR [1383:21]
15182 | | | `--PLUS -> + [1383:21]
15183 | | | |--STRING_LITERAL -> "87:1: " [1383:12]
15184 | | | `--METHOD_CALL -> ( [1383:38]
15185 | | | |--IDENT -> getCheckMessage [1383:23]
15186 | | | |--ELIST -> ELIST [1383:39]
15187 | | | | |--EXPR -> EXPR [1383:39]
15188 | | | | | `--IDENT -> MSG_ERROR [1383:39]
15189 | | | | |--COMMA -> , [1383:48]
15190 | | | | |--EXPR -> EXPR [1383:50]
15191 | | | | | `--STRING_LITERAL -> "try rcurly" [1383:50]
15192 | | | | |--COMMA -> , [1383:62]
15193 | | | | |--EXPR -> EXPR [1383:64]
15194 | | | | | `--NUM_INT -> 0 [1383:64]
15195 | | | | |--COMMA -> , [1383:65]
15196 | | | | `--EXPR -> EXPR [1383:67]
15197 | | | | `--NUM_INT -> 8 [1383:67]
15198 | | | `--RPAREN -> ) [1383:68]
15199 | | |--COMMA -> , [1383:69]
15200 | | |--EXPR -> EXPR [1384:21]
15201 | | | `--PLUS -> + [1384:21]
15202 | | | |--STRING_LITERAL -> "88:1: " [1384:12]
15203 | | | `--METHOD_CALL -> ( [1384:38]
15204 | | | |--IDENT -> getCheckMessage [1384:23]
15205 | | | |--ELIST -> ELIST [1384:39]
15206 | | | | |--EXPR -> EXPR [1384:39]
15207 | | | | | `--IDENT -> MSG_CHILD_ERROR [1384:39]
15208 | | | | |--COMMA -> , [1384:54]
15209 | | | | |--EXPR -> EXPR [1384:56]
15210 | | | | | `--STRING_LITERAL -> "catch" [1384:56]
15211 | | | | |--COMMA -> , [1384:63]
15212 | | | | |--EXPR -> EXPR [1384:65]
15213 | | | | | `--NUM_INT -> 0 [1384:65]
15214 | | | | |--COMMA -> , [1384:66]
15215 | | | | `--EXPR -> EXPR [1384:68]
15216 | | | | `--NUM_INT -> 12 [1384:68]
15217 | | | `--RPAREN -> ) [1384:70]
15218 | | |--COMMA -> , [1384:71]
15219 | | |--EXPR -> EXPR [1385:21]
15220 | | | `--PLUS -> + [1385:21]
15221 | | | |--STRING_LITERAL -> "89:1: " [1385:12]
15222 | | | `--METHOD_CALL -> ( [1385:38]
15223 | | | |--IDENT -> getCheckMessage [1385:23]
15224 | | | |--ELIST -> ELIST [1385:39]
15225 | | | | |--EXPR -> EXPR [1385:39]
15226 | | | | | `--IDENT -> MSG_ERROR [1385:39]
15227 | | | | |--COMMA -> , [1385:48]
15228 | | | | |--EXPR -> EXPR [1385:50]
15229 | | | | | `--STRING_LITERAL -> "catch rcurly" [1385:50]
15230 | | | | |--COMMA -> , [1385:64]
15231 | | | | |--EXPR -> EXPR [1385:66]
15232 | | | | | `--NUM_INT -> 0 [1385:66]
15233 | | | | |--COMMA -> , [1385:67]
15234 | | | | `--EXPR -> EXPR [1385:69]
15235 | | | | `--NUM_INT -> 8 [1385:69]
15236 | | | `--RPAREN -> ) [1385:70]
15237 | | |--COMMA -> , [1385:71]
15238 | | |--EXPR -> EXPR [1386:21]
15239 | | | `--PLUS -> + [1386:21]
15240 | | | |--STRING_LITERAL -> "91:1: " [1386:12]
15241 | | | `--METHOD_CALL -> ( [1386:38]
15242 | | | |--IDENT -> getCheckMessage [1386:23]
15243 | | | |--ELIST -> ELIST [1386:39]
15244 | | | | |--EXPR -> EXPR [1386:39]
15245 | | | | | `--IDENT -> MSG_ERROR [1386:39]
15246 | | | | |--COMMA -> , [1386:48]
15247 | | | | |--EXPR -> EXPR [1386:50]
15248 | | | | | `--STRING_LITERAL -> "try" [1386:50]
15249 | | | | |--COMMA -> , [1386:55]
15250 | | | | |--EXPR -> EXPR [1386:57]
15251 | | | | | `--NUM_INT -> 0 [1386:57]
15252 | | | | |--COMMA -> , [1386:58]
15253 | | | | `--EXPR -> EXPR [1386:60]
15254 | | | | `--NUM_INT -> 8 [1386:60]
15255 | | | `--RPAREN -> ) [1386:61]
15256 | | |--COMMA -> , [1386:62]
15257 | | |--EXPR -> EXPR [1387:21]
15258 | | | `--PLUS -> + [1387:21]
15259 | | | |--STRING_LITERAL -> "92:1: " [1387:12]
15260 | | | `--METHOD_CALL -> ( [1387:38]
15261 | | | |--IDENT -> getCheckMessage [1387:23]
15262 | | | |--ELIST -> ELIST [1387:39]
15263 | | | | |--EXPR -> EXPR [1387:39]
15264 | | | | | `--IDENT -> MSG_ERROR [1387:39]
15265 | | | | |--COMMA -> , [1387:48]
15266 | | | | |--EXPR -> EXPR [1387:50]
15267 | | | | | `--STRING_LITERAL -> "try rcurly" [1387:50]
15268 | | | | |--COMMA -> , [1387:62]
15269 | | | | |--EXPR -> EXPR [1387:64]
15270 | | | | | `--NUM_INT -> 0 [1387:64]
15271 | | | | |--COMMA -> , [1387:65]
15272 | | | | `--EXPR -> EXPR [1387:67]
15273 | | | | `--NUM_INT -> 8 [1387:67]
15274 | | | `--RPAREN -> ) [1387:68]
15275 | | |--COMMA -> , [1387:69]
15276 | | |--EXPR -> EXPR [1388:21]
15277 | | | `--PLUS -> + [1388:21]
15278 | | | |--STRING_LITERAL -> "93:1: " [1388:12]
15279 | | | `--METHOD_CALL -> ( [1388:38]
15280 | | | |--IDENT -> getCheckMessage [1388:23]
15281 | | | |--ELIST -> ELIST [1388:39]
15282 | | | | |--EXPR -> EXPR [1388:39]
15283 | | | | | `--IDENT -> MSG_CHILD_ERROR [1388:39]
15284 | | | | |--COMMA -> , [1388:54]
15285 | | | | |--EXPR -> EXPR [1388:56]
15286 | | | | | `--STRING_LITERAL -> "catch" [1388:56]
15287 | | | | |--COMMA -> , [1388:63]
15288 | | | | |--EXPR -> EXPR [1388:65]
15289 | | | | | `--NUM_INT -> 0 [1388:65]
15290 | | | | |--COMMA -> , [1388:66]
15291 | | | | `--EXPR -> EXPR [1388:68]
15292 | | | | `--NUM_INT -> 12 [1388:68]
15293 | | | `--RPAREN -> ) [1388:70]
15294 | | |--COMMA -> , [1388:71]
15295 | | |--EXPR -> EXPR [1389:21]
15296 | | | `--PLUS -> + [1389:21]
15297 | | | |--STRING_LITERAL -> "94:1: " [1389:12]
15298 | | | `--METHOD_CALL -> ( [1389:38]
15299 | | | |--IDENT -> getCheckMessage [1389:23]
15300 | | | |--ELIST -> ELIST [1389:39]
15301 | | | | |--EXPR -> EXPR [1389:39]
15302 | | | | | `--IDENT -> MSG_ERROR [1389:39]
15303 | | | | |--COMMA -> , [1389:48]
15304 | | | | |--EXPR -> EXPR [1389:50]
15305 | | | | | `--STRING_LITERAL -> "catch rcurly" [1389:50]
15306 | | | | |--COMMA -> , [1389:64]
15307 | | | | |--EXPR -> EXPR [1389:66]
15308 | | | | | `--NUM_INT -> 0 [1389:66]
15309 | | | | |--COMMA -> , [1389:67]
15310 | | | | `--EXPR -> EXPR [1389:69]
15311 | | | | `--NUM_INT -> 8 [1389:69]
15312 | | | `--RPAREN -> ) [1389:70]
15313 | | |--COMMA -> , [1389:71]
15314 | | `--RCURLY -> } [1390:8]
15315 | |--SEMI -> ; [1390:9]
15316 | |--EXPR -> EXPR [1391:19]
15317 | | `--METHOD_CALL -> ( [1391:19]
15318 | | |--IDENT -> verifyWarns [1391:8]
15319 | | |--ELIST -> ELIST [1391:20]
15320 | | | |--EXPR -> EXPR [1391:20]
15321 | | | | `--IDENT -> checkConfig [1391:20]
15322 | | | |--COMMA -> , [1391:31]
15323 | | | |--EXPR -> EXPR [1391:33]
15324 | | | | `--IDENT -> fileName [1391:33]
15325 | | | |--COMMA -> , [1391:41]
15326 | | | `--EXPR -> EXPR [1391:43]
15327 | | | `--IDENT -> expected [1391:43]
15328 | | `--RPAREN -> ) [1391:51]
15329 | |--SEMI -> ; [1391:52]
15330 | `--RCURLY -> } [1392:4]
15331 |--METHOD_DEF -> METHOD_DEF [1394:4]
15332 | |--MODIFIERS -> MODIFIERS [1394:4]
15333 | | |--ANNOTATION -> ANNOTATION [1394:4]
15334 | | | |--AT -> @ [1394:4]
15335 | | | `--IDENT -> Test [1394:5]
15336 | | `--LITERAL_PUBLIC -> public [1395:4]
15337 | |--TYPE -> TYPE [1395:11]
15338 | | `--LITERAL_VOID -> void [1395:11]
15339 | |--IDENT -> testInvalidClassDefWithChecker [1395:16]
15340 | |--LPAREN -> ( [1395:46]
15341 | |--PARAMETERS -> PARAMETERS [1395:47]
15342 | |--RPAREN -> ) [1395:47]
15343 | |--LITERAL_THROWS -> throws [1396:12]
15344 | | `--IDENT -> Exception [1396:19]
15345 | `--SLIST -> { [1396:29]
15346 | |--VARIABLE_DEF -> VARIABLE_DEF [1397:8]
15347 | | |--MODIFIERS -> MODIFIERS [1397:8]
15348 | | | `--FINAL -> final [1397:8]
15349 | | |--TYPE -> TYPE [1397:14]
15350 | | | `--IDENT -> DefaultConfiguration [1397:14]
15351 | | |--IDENT -> checkConfig [1397:35]
15352 | | `--ASSIGN -> = [1397:47]
15353 | | `--EXPR -> EXPR [1397:67]
15354 | | `--METHOD_CALL -> ( [1397:67]
15355 | | |--IDENT -> createModuleConfig [1397:49]
15356 | | |--ELIST -> ELIST [1397:84]
15357 | | | `--EXPR -> EXPR [1397:84]
15358 | | | `--DOT -> . [1397:84]
15359 | | | |--IDENT -> IndentationCheck [1397:68]
15360 | | | `--LITERAL_CLASS -> class [1397:85]
15361 | | `--RPAREN -> ) [1397:90]
15362 | |--SEMI -> ; [1397:91]
15363 | |--EXPR -> EXPR [1399:32]
15364 | | `--METHOD_CALL -> ( [1399:32]
15365 | | |--DOT -> . [1399:19]
15366 | | | |--IDENT -> checkConfig [1399:8]
15367 | | | `--IDENT -> addAttribute [1399:20]
15368 | | |--ELIST -> ELIST [1399:33]
15369 | | | |--EXPR -> EXPR [1399:33]
15370 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1399:33]
15371 | | | |--COMMA -> , [1399:50]
15372 | | | `--EXPR -> EXPR [1399:52]
15373 | | | `--STRING_LITERAL -> "4" [1399:52]
15374 | | `--RPAREN -> ) [1399:55]
15375 | |--SEMI -> ; [1399:56]
15376 | |--EXPR -> EXPR [1400:32]
15377 | | `--METHOD_CALL -> ( [1400:32]
15378 | | |--DOT -> . [1400:19]
15379 | | | |--IDENT -> checkConfig [1400:8]
15380 | | | `--IDENT -> addAttribute [1400:20]
15381 | | |--ELIST -> ELIST [1400:33]
15382 | | | |--EXPR -> EXPR [1400:33]
15383 | | | | `--STRING_LITERAL -> "basicOffset" [1400:33]
15384 | | | |--COMMA -> , [1400:46]
15385 | | | `--EXPR -> EXPR [1400:48]
15386 | | | `--STRING_LITERAL -> "4" [1400:48]
15387 | | `--RPAREN -> ) [1400:51]
15388 | |--SEMI -> ; [1400:52]
15389 | |--EXPR -> EXPR [1401:32]
15390 | | `--METHOD_CALL -> ( [1401:32]
15391 | | |--DOT -> . [1401:19]
15392 | | | |--IDENT -> checkConfig [1401:8]
15393 | | | `--IDENT -> addAttribute [1401:20]
15394 | | |--ELIST -> ELIST [1401:33]
15395 | | | |--EXPR -> EXPR [1401:33]
15396 | | | | `--STRING_LITERAL -> "braceAdjustment" [1401:33]
15397 | | | |--COMMA -> , [1401:50]
15398 | | | `--EXPR -> EXPR [1401:52]
15399 | | | `--STRING_LITERAL -> "0" [1401:52]
15400 | | `--RPAREN -> ) [1401:55]
15401 | |--SEMI -> ; [1401:56]
15402 | |--EXPR -> EXPR [1402:32]
15403 | | `--METHOD_CALL -> ( [1402:32]
15404 | | |--DOT -> . [1402:19]
15405 | | | |--IDENT -> checkConfig [1402:8]
15406 | | | `--IDENT -> addAttribute [1402:20]
15407 | | |--ELIST -> ELIST [1402:33]
15408 | | | |--EXPR -> EXPR [1402:33]
15409 | | | | `--STRING_LITERAL -> "caseIndent" [1402:33]
15410 | | | |--COMMA -> , [1402:45]
15411 | | | `--EXPR -> EXPR [1402:47]
15412 | | | `--STRING_LITERAL -> "4" [1402:47]
15413 | | `--RPAREN -> ) [1402:50]
15414 | |--SEMI -> ; [1402:51]
15415 | |--EXPR -> EXPR [1403:32]
15416 | | `--METHOD_CALL -> ( [1403:32]
15417 | | |--DOT -> . [1403:19]
15418 | | | |--IDENT -> checkConfig [1403:8]
15419 | | | `--IDENT -> addAttribute [1403:20]
15420 | | |--ELIST -> ELIST [1403:33]
15421 | | | |--EXPR -> EXPR [1403:33]
15422 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1403:33]
15423 | | | |--COMMA -> , [1403:55]
15424 | | | `--EXPR -> EXPR [1403:57]
15425 | | | `--STRING_LITERAL -> "false" [1403:57]
15426 | | `--RPAREN -> ) [1403:64]
15427 | |--SEMI -> ; [1403:65]
15428 | |--EXPR -> EXPR [1404:32]
15429 | | `--METHOD_CALL -> ( [1404:32]
15430 | | |--DOT -> . [1404:19]
15431 | | | |--IDENT -> checkConfig [1404:8]
15432 | | | `--IDENT -> addAttribute [1404:20]
15433 | | |--ELIST -> ELIST [1404:33]
15434 | | | |--EXPR -> EXPR [1404:33]
15435 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1404:33]
15436 | | | |--COMMA -> , [1404:58]
15437 | | | `--EXPR -> EXPR [1404:60]
15438 | | | `--STRING_LITERAL -> "4" [1404:60]
15439 | | `--RPAREN -> ) [1404:63]
15440 | |--SEMI -> ; [1404:64]
15441 | |--EXPR -> EXPR [1405:32]
15442 | | `--METHOD_CALL -> ( [1405:32]
15443 | | |--DOT -> . [1405:19]
15444 | | | |--IDENT -> checkConfig [1405:8]
15445 | | | `--IDENT -> addAttribute [1405:20]
15446 | | |--ELIST -> ELIST [1405:33]
15447 | | | |--EXPR -> EXPR [1405:33]
15448 | | | | `--STRING_LITERAL -> "tabWidth" [1405:33]
15449 | | | |--COMMA -> , [1405:43]
15450 | | | `--EXPR -> EXPR [1405:45]
15451 | | | `--STRING_LITERAL -> "4" [1405:45]
15452 | | `--RPAREN -> ) [1405:48]
15453 | |--SEMI -> ; [1405:49]
15454 | |--EXPR -> EXPR [1406:32]
15455 | | `--METHOD_CALL -> ( [1406:32]
15456 | | |--DOT -> . [1406:19]
15457 | | | |--IDENT -> checkConfig [1406:8]
15458 | | | `--IDENT -> addAttribute [1406:20]
15459 | | |--ELIST -> ELIST [1406:33]
15460 | | | |--EXPR -> EXPR [1406:33]
15461 | | | | `--STRING_LITERAL -> "throwsIndent" [1406:33]
15462 | | | |--COMMA -> , [1406:47]
15463 | | | `--EXPR -> EXPR [1406:49]
15464 | | | `--STRING_LITERAL -> "4" [1406:49]
15465 | | `--RPAREN -> ) [1406:52]
15466 | |--SEMI -> ; [1406:53]
15467 | |--VARIABLE_DEF -> VARIABLE_DEF [1407:8]
15468 | | |--MODIFIERS -> MODIFIERS [1407:8]
15469 | | | `--FINAL -> final [1407:8]
15470 | | |--TYPE -> TYPE [1407:14]
15471 | | | `--IDENT -> String [1407:14]
15472 | | |--IDENT -> fileName [1407:21]
15473 | | `--ASSIGN -> = [1407:30]
15474 | | `--EXPR -> EXPR [1407:39]
15475 | | `--METHOD_CALL -> ( [1407:39]
15476 | | |--IDENT -> getPath [1407:32]
15477 | | |--ELIST -> ELIST [1407:40]
15478 | | | `--EXPR -> EXPR [1407:40]
15479 | | | `--STRING_LITERAL -> "InputIndentationInvalidClassDefIndent.java" [1407:40]
15480 | | `--RPAREN -> ) [1407:84]
15481 | |--SEMI -> ; [1407:85]
15482 | |--VARIABLE_DEF -> VARIABLE_DEF [1408:8]
15483 | | |--MODIFIERS -> MODIFIERS [1408:8]
15484 | | | `--FINAL -> final [1408:8]
15485 | | |--TYPE -> TYPE [1408:20]
15486 | | | `--ARRAY_DECLARATOR -> [ [1408:20]
15487 | | | |--IDENT -> String [1408:14]
15488 | | | `--RBRACK -> ] [1408:21]
15489 | | |--IDENT -> expected [1408:23]
15490 | | `--ASSIGN -> = [1408:32]
15491 | | `--ARRAY_INIT -> { [1408:34]
15492 | | |--EXPR -> EXPR [1409:21]
15493 | | | `--PLUS -> + [1409:21]
15494 | | | |--STRING_LITERAL -> "22:3: " [1409:12]
15495 | | | `--METHOD_CALL -> ( [1409:38]
15496 | | | |--IDENT -> getCheckMessage [1409:23]
15497 | | | |--ELIST -> ELIST [1409:39]
15498 | | | | |--EXPR -> EXPR [1409:39]
15499 | | | | | `--IDENT -> MSG_ERROR [1409:39]
15500 | | | | |--COMMA -> , [1409:48]
15501 | | | | |--EXPR -> EXPR [1409:50]
15502 | | | | | `--STRING_LITERAL -> "class def modifier" [1409:50]
15503 | | | | |--COMMA -> , [1409:70]
15504 | | | | |--EXPR -> EXPR [1409:72]
15505 | | | | | `--NUM_INT -> 2 [1409:72]
15506 | | | | |--COMMA -> , [1409:73]
15507 | | | | `--EXPR -> EXPR [1409:75]
15508 | | | | `--NUM_INT -> 0 [1409:75]
15509 | | | `--RPAREN -> ) [1409:76]
15510 | | |--COMMA -> , [1409:77]
15511 | | |--EXPR -> EXPR [1410:21]
15512 | | | `--PLUS -> + [1410:21]
15513 | | | |--STRING_LITERAL -> "28:3: " [1410:12]
15514 | | | `--METHOD_CALL -> ( [1410:38]
15515 | | | |--IDENT -> getCheckMessage [1410:23]
15516 | | | |--ELIST -> ELIST [1410:39]
15517 | | | | |--EXPR -> EXPR [1410:39]
15518 | | | | | `--IDENT -> MSG_ERROR [1410:39]
15519 | | | | |--COMMA -> , [1410:48]
15520 | | | | |--EXPR -> EXPR [1410:50]
15521 | | | | | `--STRING_LITERAL -> "class def lcurly" [1410:50]
15522 | | | | |--COMMA -> , [1410:68]
15523 | | | | |--EXPR -> EXPR [1410:70]
15524 | | | | | `--NUM_INT -> 2 [1410:70]
15525 | | | | |--COMMA -> , [1410:71]
15526 | | | | `--EXPR -> EXPR [1410:73]
15527 | | | | `--NUM_INT -> 0 [1410:73]
15528 | | | `--RPAREN -> ) [1410:74]
15529 | | |--COMMA -> , [1410:75]
15530 | | |--EXPR -> EXPR [1411:21]
15531 | | | `--PLUS -> + [1411:21]
15532 | | | |--STRING_LITERAL -> "31:3: " [1411:12]
15533 | | | `--METHOD_CALL -> ( [1411:38]
15534 | | | |--IDENT -> getCheckMessage [1411:23]
15535 | | | |--ELIST -> ELIST [1411:39]
15536 | | | | |--EXPR -> EXPR [1411:39]
15537 | | | | | `--IDENT -> MSG_ERROR [1411:39]
15538 | | | | |--COMMA -> , [1411:48]
15539 | | | | |--EXPR -> EXPR [1411:50]
15540 | | | | | `--STRING_LITERAL -> "class def rcurly" [1411:50]
15541 | | | | |--COMMA -> , [1411:68]
15542 | | | | |--EXPR -> EXPR [1411:70]
15543 | | | | | `--NUM_INT -> 2 [1411:70]
15544 | | | | |--COMMA -> , [1411:71]
15545 | | | | `--EXPR -> EXPR [1411:73]
15546 | | | | `--NUM_INT -> 0 [1411:73]
15547 | | | `--RPAREN -> ) [1411:74]
15548 | | |--COMMA -> , [1411:75]
15549 | | |--EXPR -> EXPR [1412:21]
15550 | | | `--PLUS -> + [1412:21]
15551 | | | |--STRING_LITERAL -> "34:9: " [1412:12]
15552 | | | `--METHOD_CALL -> ( [1412:38]
15553 | | | |--IDENT -> getCheckMessage [1412:23]
15554 | | | |--ELIST -> ELIST [1412:39]
15555 | | | | |--EXPR -> EXPR [1412:39]
15556 | | | | | `--IDENT -> MSG_ERROR [1412:39]
15557 | | | | |--COMMA -> , [1412:48]
15558 | | | | |--EXPR -> EXPR [1412:50]
15559 | | | | | `--STRING_LITERAL -> "class def ident" [1412:50]
15560 | | | | |--COMMA -> , [1412:67]
15561 | | | | |--EXPR -> EXPR [1412:69]
15562 | | | | | `--NUM_INT -> 2 [1412:69]
15563 | | | | |--COMMA -> , [1412:70]
15564 | | | | `--EXPR -> EXPR [1412:72]
15565 | | | | `--NUM_INT -> 0 [1412:72]
15566 | | | `--RPAREN -> ) [1412:73]
15567 | | |--COMMA -> , [1412:74]
15568 | | |--EXPR -> EXPR [1413:21]
15569 | | | `--PLUS -> + [1413:21]
15570 | | | |--STRING_LITERAL -> "38:3: " [1413:12]
15571 | | | `--METHOD_CALL -> ( [1413:38]
15572 | | | |--IDENT -> getCheckMessage [1413:23]
15573 | | | |--ELIST -> ELIST [1413:39]
15574 | | | | |--EXPR -> EXPR [1413:39]
15575 | | | | | `--IDENT -> MSG_ERROR [1413:39]
15576 | | | | |--COMMA -> , [1413:48]
15577 | | | | |--EXPR -> EXPR [1413:50]
15578 | | | | | `--STRING_LITERAL -> "class def rcurly" [1413:50]
15579 | | | | |--COMMA -> , [1413:68]
15580 | | | | |--EXPR -> EXPR [1413:70]
15581 | | | | | `--NUM_INT -> 2 [1413:70]
15582 | | | | |--COMMA -> , [1413:71]
15583 | | | | `--EXPR -> EXPR [1413:73]
15584 | | | | `--NUM_INT -> 0 [1413:73]
15585 | | | `--RPAREN -> ) [1413:74]
15586 | | |--COMMA -> , [1413:75]
15587 | | |--EXPR -> EXPR [1414:21]
15588 | | | `--PLUS -> + [1414:21]
15589 | | | |--STRING_LITERAL -> "43:3: " [1414:12]
15590 | | | `--METHOD_CALL -> ( [1414:38]
15591 | | | |--IDENT -> getCheckMessage [1414:23]
15592 | | | |--ELIST -> ELIST [1414:39]
15593 | | | | |--EXPR -> EXPR [1414:39]
15594 | | | | | `--IDENT -> MSG_ERROR [1414:39]
15595 | | | | |--COMMA -> , [1414:48]
15596 | | | | |--EXPR -> EXPR [1414:50]
15597 | | | | | `--STRING_LITERAL -> "extends" [1414:50]
15598 | | | | |--COMMA -> , [1414:59]
15599 | | | | |--EXPR -> EXPR [1414:61]
15600 | | | | | `--NUM_INT -> 2 [1414:61]
15601 | | | | |--COMMA -> , [1414:62]
15602 | | | | `--EXPR -> EXPR [1414:64]
15603 | | | | `--NUM_INT -> 4 [1414:64]
15604 | | | `--RPAREN -> ) [1414:65]
15605 | | |--COMMA -> , [1414:66]
15606 | | |--EXPR -> EXPR [1415:21]
15607 | | | `--PLUS -> + [1415:21]
15608 | | | |--STRING_LITERAL -> "44:3: " [1415:12]
15609 | | | `--METHOD_CALL -> ( [1415:38]
15610 | | | |--IDENT -> getCheckMessage [1415:23]
15611 | | | |--ELIST -> ELIST [1415:39]
15612 | | | | |--EXPR -> EXPR [1415:39]
15613 | | | | | `--IDENT -> MSG_ERROR [1415:39]
15614 | | | | |--COMMA -> , [1415:48]
15615 | | | | |--EXPR -> EXPR [1415:50]
15616 | | | | | `--STRING_LITERAL -> "implements" [1415:50]
15617 | | | | |--COMMA -> , [1415:62]
15618 | | | | |--EXPR -> EXPR [1415:64]
15619 | | | | | `--NUM_INT -> 2 [1415:64]
15620 | | | | |--COMMA -> , [1415:65]
15621 | | | | `--EXPR -> EXPR [1415:67]
15622 | | | | `--NUM_INT -> 4 [1415:67]
15623 | | | `--RPAREN -> ) [1415:68]
15624 | | |--COMMA -> , [1415:69]
15625 | | |--EXPR -> EXPR [1416:21]
15626 | | | `--PLUS -> + [1416:21]
15627 | | | |--STRING_LITERAL -> "50:3: " [1416:12]
15628 | | | `--METHOD_CALL -> ( [1416:38]
15629 | | | |--IDENT -> getCheckMessage [1416:23]
15630 | | | |--ELIST -> ELIST [1416:39]
15631 | | | | |--EXPR -> EXPR [1416:39]
15632 | | | | | `--IDENT -> MSG_ERROR [1416:39]
15633 | | | | |--COMMA -> , [1416:48]
15634 | | | | |--EXPR -> EXPR [1416:50]
15635 | | | | | `--STRING_LITERAL -> "extends" [1416:50]
15636 | | | | |--COMMA -> , [1416:59]
15637 | | | | |--EXPR -> EXPR [1416:61]
15638 | | | | | `--NUM_INT -> 2 [1416:61]
15639 | | | | |--COMMA -> , [1416:62]
15640 | | | | `--EXPR -> EXPR [1416:64]
15641 | | | | `--NUM_INT -> 4 [1416:64]
15642 | | | `--RPAREN -> ) [1416:65]
15643 | | |--COMMA -> , [1416:66]
15644 | | |--EXPR -> EXPR [1417:21]
15645 | | | `--PLUS -> + [1417:21]
15646 | | | |--STRING_LITERAL -> "58:3: " [1417:12]
15647 | | | `--METHOD_CALL -> ( [1417:38]
15648 | | | |--IDENT -> getCheckMessage [1417:23]
15649 | | | |--ELIST -> ELIST [1417:39]
15650 | | | | |--EXPR -> EXPR [1417:39]
15651 | | | | | `--IDENT -> MSG_ERROR [1417:39]
15652 | | | | |--COMMA -> , [1417:48]
15653 | | | | |--EXPR -> EXPR [1417:50]
15654 | | | | | `--STRING_LITERAL -> "implements" [1417:50]
15655 | | | | |--COMMA -> , [1417:62]
15656 | | | | |--EXPR -> EXPR [1417:64]
15657 | | | | | `--NUM_INT -> 2 [1417:64]
15658 | | | | |--COMMA -> , [1417:65]
15659 | | | | `--EXPR -> EXPR [1417:67]
15660 | | | | `--NUM_INT -> 4 [1417:67]
15661 | | | `--RPAREN -> ) [1417:68]
15662 | | |--COMMA -> , [1417:69]
15663 | | |--EXPR -> EXPR [1418:21]
15664 | | | `--PLUS -> + [1418:21]
15665 | | | |--STRING_LITERAL -> "59:3: " [1418:12]
15666 | | | `--METHOD_CALL -> ( [1418:38]
15667 | | | |--IDENT -> getCheckMessage [1418:23]
15668 | | | |--ELIST -> ELIST [1418:39]
15669 | | | | |--EXPR -> EXPR [1418:39]
15670 | | | | | `--IDENT -> MSG_ERROR [1418:39]
15671 | | | | |--COMMA -> , [1418:48]
15672 | | | | |--EXPR -> EXPR [1418:50]
15673 | | | | | `--STRING_LITERAL -> "java" [1418:50]
15674 | | | | |--COMMA -> , [1418:56]
15675 | | | | |--EXPR -> EXPR [1418:58]
15676 | | | | | `--NUM_INT -> 2 [1418:58]
15677 | | | | |--COMMA -> , [1418:59]
15678 | | | | `--EXPR -> EXPR [1418:61]
15679 | | | | `--NUM_INT -> 4 [1418:61]
15680 | | | `--RPAREN -> ) [1418:62]
15681 | | |--COMMA -> , [1418:63]
15682 | | |--EXPR -> EXPR [1419:21]
15683 | | | `--PLUS -> + [1419:21]
15684 | | | |--STRING_LITERAL -> "64:3: " [1419:12]
15685 | | | `--METHOD_CALL -> ( [1419:38]
15686 | | | |--IDENT -> getCheckMessage [1419:23]
15687 | | | |--ELIST -> ELIST [1419:39]
15688 | | | | |--EXPR -> EXPR [1419:39]
15689 | | | | | `--IDENT -> MSG_ERROR [1419:39]
15690 | | | | |--COMMA -> , [1419:48]
15691 | | | | |--EXPR -> EXPR [1419:50]
15692 | | | | | `--STRING_LITERAL -> "class def modifier" [1419:50]
15693 | | | | |--COMMA -> , [1419:70]
15694 | | | | |--EXPR -> EXPR [1419:72]
15695 | | | | | `--NUM_INT -> 2 [1419:72]
15696 | | | | |--COMMA -> , [1419:73]
15697 | | | | `--EXPR -> EXPR [1419:75]
15698 | | | | `--NUM_INT -> 0 [1419:75]
15699 | | | `--RPAREN -> ) [1419:76]
15700 | | |--COMMA -> , [1419:77]
15701 | | |--EXPR -> EXPR [1420:21]
15702 | | | `--PLUS -> + [1420:21]
15703 | | | |--STRING_LITERAL -> "65:3: " [1420:12]
15704 | | | `--METHOD_CALL -> ( [1420:38]
15705 | | | |--IDENT -> getCheckMessage [1420:23]
15706 | | | |--ELIST -> ELIST [1420:39]
15707 | | | | |--EXPR -> EXPR [1420:39]
15708 | | | | | `--IDENT -> MSG_ERROR [1420:39]
15709 | | | | |--COMMA -> , [1420:48]
15710 | | | | |--EXPR -> EXPR [1420:50]
15711 | | | | | `--STRING_LITERAL -> "class def lcurly" [1420:50]
15712 | | | | |--COMMA -> , [1420:68]
15713 | | | | |--EXPR -> EXPR [1420:70]
15714 | | | | | `--NUM_INT -> 2 [1420:70]
15715 | | | | |--COMMA -> , [1420:71]
15716 | | | | `--EXPR -> EXPR [1420:73]
15717 | | | | `--NUM_INT -> 0 [1420:73]
15718 | | | `--RPAREN -> ) [1420:74]
15719 | | |--COMMA -> , [1420:75]
15720 | | |--EXPR -> EXPR [1421:21]
15721 | | | `--PLUS -> + [1421:21]
15722 | | | |--STRING_LITERAL -> "73:3: " [1421:12]
15723 | | | `--METHOD_CALL -> ( [1421:38]
15724 | | | |--IDENT -> getCheckMessage [1421:23]
15725 | | | |--ELIST -> ELIST [1421:39]
15726 | | | | |--EXPR -> EXPR [1421:39]
15727 | | | | | `--IDENT -> MSG_ERROR [1421:39]
15728 | | | | |--COMMA -> , [1421:48]
15729 | | | | |--EXPR -> EXPR [1421:50]
15730 | | | | | `--STRING_LITERAL -> "class def rcurly" [1421:50]
15731 | | | | |--COMMA -> , [1421:68]
15732 | | | | |--EXPR -> EXPR [1421:70]
15733 | | | | | `--NUM_INT -> 2 [1421:70]
15734 | | | | |--COMMA -> , [1421:71]
15735 | | | | `--EXPR -> EXPR [1421:73]
15736 | | | | `--NUM_INT -> 0 [1421:73]
15737 | | | `--RPAREN -> ) [1421:74]
15738 | | |--COMMA -> , [1421:75]
15739 | | |--EXPR -> EXPR [1422:21]
15740 | | | `--PLUS -> + [1422:21]
15741 | | | |--STRING_LITERAL -> "77:3: " [1422:12]
15742 | | | `--METHOD_CALL -> ( [1422:38]
15743 | | | |--IDENT -> getCheckMessage [1422:23]
15744 | | | |--ELIST -> ELIST [1422:39]
15745 | | | | |--EXPR -> EXPR [1422:39]
15746 | | | | | `--IDENT -> MSG_ERROR [1422:39]
15747 | | | | |--COMMA -> , [1422:48]
15748 | | | | |--EXPR -> EXPR [1422:50]
15749 | | | | | `--STRING_LITERAL -> "extends" [1422:50]
15750 | | | | |--COMMA -> , [1422:59]
15751 | | | | |--EXPR -> EXPR [1422:61]
15752 | | | | | `--NUM_INT -> 2 [1422:61]
15753 | | | | |--COMMA -> , [1422:62]
15754 | | | | `--EXPR -> EXPR [1422:64]
15755 | | | | `--NUM_INT -> 4 [1422:64]
15756 | | | `--RPAREN -> ) [1422:65]
15757 | | |--COMMA -> , [1422:66]
15758 | | |--EXPR -> EXPR [1423:21]
15759 | | | `--PLUS -> + [1423:21]
15760 | | | |--STRING_LITERAL -> "86:9: " [1423:12]
15761 | | | `--METHOD_CALL -> ( [1423:38]
15762 | | | |--IDENT -> getCheckMessage [1423:23]
15763 | | | |--ELIST -> ELIST [1423:39]
15764 | | | | |--EXPR -> EXPR [1423:39]
15765 | | | | | `--IDENT -> MSG_ERROR [1423:39]
15766 | | | | |--COMMA -> , [1423:48]
15767 | | | | |--EXPR -> EXPR [1423:50]
15768 | | | | | `--STRING_LITERAL -> "class def ident" [1423:50]
15769 | | | | |--COMMA -> , [1423:67]
15770 | | | | |--EXPR -> EXPR [1423:69]
15771 | | | | | `--NUM_INT -> 2 [1423:69]
15772 | | | | |--COMMA -> , [1423:70]
15773 | | | | `--EXPR -> EXPR [1423:72]
15774 | | | | `--NUM_INT -> 4 [1423:72]
15775 | | | `--RPAREN -> ) [1423:73]
15776 | | |--COMMA -> , [1423:74]
15777 | | |--EXPR -> EXPR [1424:22]
15778 | | | `--PLUS -> + [1424:22]
15779 | | | |--STRING_LITERAL -> "88:13: " [1424:12]
15780 | | | `--METHOD_CALL -> ( [1424:39]
15781 | | | |--IDENT -> getCheckMessage [1424:24]
15782 | | | |--ELIST -> ELIST [1424:40]
15783 | | | | |--EXPR -> EXPR [1424:40]
15784 | | | | | `--IDENT -> MSG_ERROR [1424:40]
15785 | | | | |--COMMA -> , [1424:49]
15786 | | | | |--EXPR -> EXPR [1424:51]
15787 | | | | | `--STRING_LITERAL -> "class def ident" [1424:51]
15788 | | | | |--COMMA -> , [1424:68]
15789 | | | | |--EXPR -> EXPR [1424:70]
15790 | | | | | `--NUM_INT -> 6 [1424:70]
15791 | | | | |--COMMA -> , [1424:71]
15792 | | | | `--EXPR -> EXPR [1424:73]
15793 | | | | `--NUM_INT -> 4 [1424:73]
15794 | | | `--RPAREN -> ) [1424:74]
15795 | | |--COMMA -> , [1424:75]
15796 | | |--EXPR -> EXPR [1425:21]
15797 | | | `--PLUS -> + [1425:21]
15798 | | | |--STRING_LITERAL -> "91:9: " [1425:12]
15799 | | | `--METHOD_CALL -> ( [1425:38]
15800 | | | |--IDENT -> getCheckMessage [1425:23]
15801 | | | |--ELIST -> ELIST [1425:39]
15802 | | | | |--EXPR -> EXPR [1425:39]
15803 | | | | | `--IDENT -> MSG_ERROR [1425:39]
15804 | | | | |--COMMA -> , [1425:48]
15805 | | | | |--EXPR -> EXPR [1425:50]
15806 | | | | | `--STRING_LITERAL -> "class def ident" [1425:50]
15807 | | | | |--COMMA -> , [1425:67]
15808 | | | | |--EXPR -> EXPR [1425:69]
15809 | | | | | `--NUM_INT -> 2 [1425:69]
15810 | | | | |--COMMA -> , [1425:70]
15811 | | | | `--EXPR -> EXPR [1425:72]
15812 | | | | `--NUM_INT -> 4 [1425:72]
15813 | | | `--RPAREN -> ) [1425:73]
15814 | | |--COMMA -> , [1425:74]
15815 | | |--EXPR -> EXPR [1426:21]
15816 | | | `--PLUS -> + [1426:21]
15817 | | | |--STRING_LITERAL -> "95:7: " [1426:12]
15818 | | | `--METHOD_CALL -> ( [1426:38]
15819 | | | |--IDENT -> getCheckMessage [1426:23]
15820 | | | |--ELIST -> ELIST [1426:39]
15821 | | | | |--EXPR -> EXPR [1426:39]
15822 | | | | | `--IDENT -> MSG_ERROR [1426:39]
15823 | | | | |--COMMA -> , [1426:48]
15824 | | | | |--EXPR -> EXPR [1426:50]
15825 | | | | | `--STRING_LITERAL -> "member def modifier" [1426:50]
15826 | | | | |--COMMA -> , [1426:71]
15827 | | | | |--EXPR -> EXPR [1426:73]
15828 | | | | | `--NUM_INT -> 6 [1426:73]
15829 | | | | |--COMMA -> , [1426:74]
15830 | | | | `--EXPR -> EXPR [1426:76]
15831 | | | | `--NUM_INT -> 8 [1426:76]
15832 | | | `--RPAREN -> ) [1426:77]
15833 | | |--COMMA -> , [1426:78]
15834 | | |--EXPR -> EXPR [1427:23]
15835 | | | `--PLUS -> + [1427:23]
15836 | | | |--STRING_LITERAL -> "101:11: " [1427:12]
15837 | | | `--METHOD_CALL -> ( [1427:40]
15838 | | | |--IDENT -> getCheckMessage [1427:25]
15839 | | | |--ELIST -> ELIST [1427:41]
15840 | | | | |--EXPR -> EXPR [1427:41]
15841 | | | | | `--IDENT -> MSG_ERROR [1427:41]
15842 | | | | |--COMMA -> , [1427:50]
15843 | | | | |--EXPR -> EXPR [1427:52]
15844 | | | | | `--STRING_LITERAL -> "int" [1427:52]
15845 | | | | |--COMMA -> , [1427:57]
15846 | | | | |--EXPR -> EXPR [1427:59]
15847 | | | | | `--NUM_INT -> 10 [1427:59]
15848 | | | | |--COMMA -> , [1427:61]
15849 | | | | `--EXPR -> EXPR [1427:63]
15850 | | | | `--NUM_INT -> 12 [1427:63]
15851 | | | `--RPAREN -> ) [1427:65]
15852 | | |--COMMA -> , [1427:66]
15853 | | |--EXPR -> EXPR [1428:22]
15854 | | | `--PLUS -> + [1428:22]
15855 | | | |--STRING_LITERAL -> "106:7: " [1428:12]
15856 | | | `--METHOD_CALL -> ( [1428:39]
15857 | | | |--IDENT -> getCheckMessage [1428:24]
15858 | | | |--ELIST -> ELIST [1428:40]
15859 | | | | |--EXPR -> EXPR [1428:40]
15860 | | | | | `--IDENT -> MSG_ERROR [1428:40]
15861 | | | | |--COMMA -> , [1428:49]
15862 | | | | |--EXPR -> EXPR [1428:51]
15863 | | | | | `--STRING_LITERAL -> "member def modifier" [1428:51]
15864 | | | | |--COMMA -> , [1428:72]
15865 | | | | |--EXPR -> EXPR [1428:74]
15866 | | | | | `--NUM_INT -> 6 [1428:74]
15867 | | | | |--COMMA -> , [1428:75]
15868 | | | | `--EXPR -> EXPR [1428:77]
15869 | | | | `--NUM_INT -> 8 [1428:77]
15870 | | | `--RPAREN -> ) [1428:78]
15871 | | |--COMMA -> , [1428:79]
15872 | | |--EXPR -> EXPR [1429:22]
15873 | | | `--PLUS -> + [1429:22]
15874 | | | |--STRING_LITERAL -> "111:7: " [1429:12]
15875 | | | `--METHOD_CALL -> ( [1429:39]
15876 | | | |--IDENT -> getCheckMessage [1429:24]
15877 | | | |--ELIST -> ELIST [1429:40]
15878 | | | | |--EXPR -> EXPR [1429:40]
15879 | | | | | `--IDENT -> MSG_ERROR [1429:40]
15880 | | | | |--COMMA -> , [1429:49]
15881 | | | | |--EXPR -> EXPR [1429:51]
15882 | | | | | `--STRING_LITERAL -> "class def rcurly" [1429:51]
15883 | | | | |--COMMA -> , [1429:69]
15884 | | | | |--EXPR -> EXPR [1429:71]
15885 | | | | | `--NUM_INT -> 6 [1429:71]
15886 | | | | |--COMMA -> , [1429:72]
15887 | | | | `--EXPR -> EXPR [1429:74]
15888 | | | | `--NUM_INT -> 4 [1429:74]
15889 | | | `--RPAREN -> ) [1429:75]
15890 | | |--COMMA -> , [1429:76]
15891 | | |--EXPR -> EXPR [1430:23]
15892 | | | `--PLUS -> + [1430:23]
15893 | | | |--STRING_LITERAL -> "113:13: " [1430:12]
15894 | | | `--METHOD_CALL -> ( [1430:40]
15895 | | | |--IDENT -> getCheckMessage [1430:25]
15896 | | | |--ELIST -> ELIST [1430:41]
15897 | | | | |--EXPR -> EXPR [1430:41]
15898 | | | | | `--IDENT -> MSG_ERROR [1430:41]
15899 | | | | |--COMMA -> , [1430:50]
15900 | | | | |--EXPR -> EXPR [1430:52]
15901 | | | | | `--STRING_LITERAL -> "class def ident" [1430:52]
15902 | | | | |--COMMA -> , [1430:69]
15903 | | | | |--EXPR -> EXPR [1430:71]
15904 | | | | | `--NUM_INT -> 6 [1430:71]
15905 | | | | |--COMMA -> , [1430:72]
15906 | | | | `--EXPR -> EXPR [1430:74]
15907 | | | | `--NUM_INT -> 4 [1430:74]
15908 | | | `--RPAREN -> ) [1430:75]
15909 | | |--COMMA -> , [1430:76]
15910 | | |--EXPR -> EXPR [1431:23]
15911 | | | `--PLUS -> + [1431:23]
15912 | | | |--STRING_LITERAL -> "119:13: " [1431:12]
15913 | | | `--METHOD_CALL -> ( [1431:40]
15914 | | | |--IDENT -> getCheckMessage [1431:25]
15915 | | | |--ELIST -> ELIST [1431:41]
15916 | | | | |--EXPR -> EXPR [1431:41]
15917 | | | | | `--IDENT -> MSG_ERROR [1431:41]
15918 | | | | |--COMMA -> , [1431:50]
15919 | | | | |--EXPR -> EXPR [1431:52]
15920 | | | | | `--STRING_LITERAL -> "class def ident" [1431:52]
15921 | | | | |--COMMA -> , [1431:69]
15922 | | | | |--EXPR -> EXPR [1431:71]
15923 | | | | | `--NUM_INT -> 6 [1431:71]
15924 | | | | |--COMMA -> , [1431:72]
15925 | | | | `--EXPR -> EXPR [1431:74]
15926 | | | | `--NUM_INT -> 8 [1431:74]
15927 | | | `--RPAREN -> ) [1431:75]
15928 | | |--COMMA -> , [1431:76]
15929 | | |--EXPR -> EXPR [1432:23]
15930 | | | `--PLUS -> + [1432:23]
15931 | | | |--STRING_LITERAL -> "122:17: " [1432:12]
15932 | | | `--METHOD_CALL -> ( [1432:40]
15933 | | | |--IDENT -> getCheckMessage [1432:25]
15934 | | | |--ELIST -> ELIST [1432:41]
15935 | | | | |--EXPR -> EXPR [1432:41]
15936 | | | | | `--IDENT -> MSG_ERROR [1432:41]
15937 | | | | |--COMMA -> , [1432:50]
15938 | | | | |--EXPR -> EXPR [1432:52]
15939 | | | | | `--STRING_LITERAL -> "class def ident" [1432:52]
15940 | | | | |--COMMA -> , [1432:69]
15941 | | | | |--EXPR -> EXPR [1432:71]
15942 | | | | | `--NUM_INT -> 10 [1432:71]
15943 | | | | |--COMMA -> , [1432:73]
15944 | | | | `--EXPR -> EXPR [1432:75]
15945 | | | | `--NUM_INT -> 8 [1432:75]
15946 | | | `--RPAREN -> ) [1432:76]
15947 | | |--COMMA -> , [1432:77]
15948 | | |--EXPR -> EXPR [1433:23]
15949 | | | `--PLUS -> + [1433:23]
15950 | | | |--STRING_LITERAL -> "124:11: " [1433:12]
15951 | | | `--METHOD_CALL -> ( [1433:40]
15952 | | | |--IDENT -> getCheckMessage [1433:25]
15953 | | | |--ELIST -> ELIST [1433:41]
15954 | | | | |--EXPR -> EXPR [1433:41]
15955 | | | | | `--IDENT -> MSG_ERROR [1433:41]
15956 | | | | |--COMMA -> , [1433:50]
15957 | | | | |--EXPR -> EXPR [1433:52]
15958 | | | | | `--STRING_LITERAL -> "class def rcurly" [1433:52]
15959 | | | | |--COMMA -> , [1433:70]
15960 | | | | |--EXPR -> EXPR [1433:72]
15961 | | | | | `--NUM_INT -> 10 [1433:72]
15962 | | | | |--COMMA -> , [1433:74]
15963 | | | | `--EXPR -> EXPR [1433:76]
15964 | | | | `--NUM_INT -> 8 [1433:76]
15965 | | | `--RPAREN -> ) [1433:77]
15966 | | |--COMMA -> , [1433:78]
15967 | | |--EXPR -> EXPR [1434:23]
15968 | | | `--PLUS -> + [1434:23]
15969 | | | |--STRING_LITERAL -> "127:11: " [1434:12]
15970 | | | `--METHOD_CALL -> ( [1434:40]
15971 | | | |--IDENT -> getCheckMessage [1434:25]
15972 | | | |--ELIST -> ELIST [1434:41]
15973 | | | | |--EXPR -> EXPR [1434:41]
15974 | | | | | `--IDENT -> MSG_ERROR [1434:41]
15975 | | | | |--COMMA -> , [1434:50]
15976 | | | | |--EXPR -> EXPR [1434:52]
15977 | | | | | `--STRING_LITERAL -> "member def type" [1434:52]
15978 | | | | |--COMMA -> , [1434:69]
15979 | | | | |--EXPR -> EXPR [1434:71]
15980 | | | | | `--NUM_INT -> 10 [1434:71]
15981 | | | | |--COMMA -> , [1434:73]
15982 | | | | `--EXPR -> EXPR [1434:75]
15983 | | | | `--NUM_INT -> 12 [1434:75]
15984 | | | `--RPAREN -> ) [1434:77]
15985 | | |--COMMA -> , [1434:78]
15986 | | |--EXPR -> EXPR [1435:23]
15987 | | | `--PLUS -> + [1435:23]
15988 | | | |--STRING_LITERAL -> "132:11: " [1435:12]
15989 | | | `--METHOD_CALL -> ( [1435:40]
15990 | | | |--IDENT -> getCheckMessage [1435:25]
15991 | | | |--ELIST -> ELIST [1435:41]
15992 | | | | |--EXPR -> EXPR [1435:41]
15993 | | | | | `--IDENT -> MSG_CHILD_ERROR [1435:41]
15994 | | | | |--COMMA -> , [1435:56]
15995 | | | | |--EXPR -> EXPR [1435:58]
15996 | | | | | `--STRING_LITERAL -> "method def" [1435:58]
15997 | | | | |--COMMA -> , [1435:70]
15998 | | | | |--EXPR -> EXPR [1435:72]
15999 | | | | | `--NUM_INT -> 10 [1435:72]
16000 | | | | |--COMMA -> , [1435:74]
16001 | | | | `--EXPR -> EXPR [1435:76]
16002 | | | | `--NUM_INT -> 8 [1435:76]
16003 | | | `--RPAREN -> ) [1435:77]
16004 | | |--COMMA -> , [1435:78]
16005 | | |--EXPR -> EXPR [1436:22]
16006 | | | `--PLUS -> + [1436:22]
16007 | | | |--STRING_LITERAL -> "133:9: " [1436:12]
16008 | | | `--METHOD_CALL -> ( [1436:39]
16009 | | | |--IDENT -> getCheckMessage [1436:24]
16010 | | | |--ELIST -> ELIST [1436:40]
16011 | | | | |--EXPR -> EXPR [1436:40]
16012 | | | | | `--IDENT -> MSG_ERROR_MULTI [1436:40]
16013 | | | | |--COMMA -> , [1436:55]
16014 | | | | |--EXPR -> EXPR [1436:57]
16015 | | | | | `--STRING_LITERAL -> "object def lcurly" [1436:57]
16016 | | | | |--COMMA -> , [1436:76]
16017 | | | | |--EXPR -> EXPR [1436:78]
16018 | | | | | `--NUM_INT -> 8 [1436:78]
16019 | | | | |--COMMA -> , [1436:79]
16020 | | | | `--EXPR -> EXPR [1436:81]
16021 | | | | `--STRING_LITERAL -> "10, 14" [1436:81]
16022 | | | `--RPAREN -> ) [1436:89]
16023 | | |--COMMA -> , [1436:90]
16024 | | |--EXPR -> EXPR [1437:22]
16025 | | | `--PLUS -> + [1437:22]
16026 | | | |--STRING_LITERAL -> "137:9: " [1437:12]
16027 | | | `--METHOD_CALL -> ( [1437:39]
16028 | | | |--IDENT -> getCheckMessage [1437:24]
16029 | | | |--ELIST -> ELIST [1437:40]
16030 | | | | |--EXPR -> EXPR [1437:40]
16031 | | | | | `--IDENT -> MSG_ERROR_MULTI [1437:40]
16032 | | | | |--COMMA -> , [1437:55]
16033 | | | | |--EXPR -> EXPR [1437:57]
16034 | | | | | `--STRING_LITERAL -> "object def rcurly" [1437:57]
16035 | | | | |--COMMA -> , [1437:76]
16036 | | | | |--EXPR -> EXPR [1437:78]
16037 | | | | | `--NUM_INT -> 8 [1437:78]
16038 | | | | |--COMMA -> , [1437:79]
16039 | | | | `--EXPR -> EXPR [1437:81]
16040 | | | | `--STRING_LITERAL -> "10, 14" [1437:81]
16041 | | | `--RPAREN -> ) [1437:89]
16042 | | |--COMMA -> , [1437:90]
16043 | | |--EXPR -> EXPR [1438:22]
16044 | | | `--PLUS -> + [1438:22]
16045 | | | |--STRING_LITERAL -> "141:7: " [1438:12]
16046 | | | `--METHOD_CALL -> ( [1438:39]
16047 | | | |--IDENT -> getCheckMessage [1438:24]
16048 | | | |--ELIST -> ELIST [1438:40]
16049 | | | | |--EXPR -> EXPR [1438:40]
16050 | | | | | `--IDENT -> MSG_ERROR_MULTI [1438:40]
16051 | | | | |--COMMA -> , [1438:55]
16052 | | | | |--EXPR -> EXPR [1438:57]
16053 | | | | | `--STRING_LITERAL -> "object def lcurly" [1438:57]
16054 | | | | |--COMMA -> , [1438:76]
16055 | | | | |--EXPR -> EXPR [1438:78]
16056 | | | | | `--NUM_INT -> 6 [1438:78]
16057 | | | | |--COMMA -> , [1438:79]
16058 | | | | `--EXPR -> EXPR [1438:81]
16059 | | | | `--STRING_LITERAL -> "8, 12" [1438:81]
16060 | | | `--RPAREN -> ) [1438:88]
16061 | | |--COMMA -> , [1438:89]
16062 | | |--EXPR -> EXPR [1439:22]
16063 | | | `--PLUS -> + [1439:22]
16064 | | | |--STRING_LITERAL -> "145:7: " [1439:12]
16065 | | | `--METHOD_CALL -> ( [1439:39]
16066 | | | |--IDENT -> getCheckMessage [1439:24]
16067 | | | |--ELIST -> ELIST [1439:40]
16068 | | | | |--EXPR -> EXPR [1439:40]
16069 | | | | | `--IDENT -> MSG_ERROR_MULTI [1439:40]
16070 | | | | |--COMMA -> , [1439:55]
16071 | | | | |--EXPR -> EXPR [1439:57]
16072 | | | | | `--STRING_LITERAL -> "object def rcurly" [1439:57]
16073 | | | | |--COMMA -> , [1439:76]
16074 | | | | |--EXPR -> EXPR [1439:78]
16075 | | | | | `--NUM_INT -> 6 [1439:78]
16076 | | | | |--COMMA -> , [1439:79]
16077 | | | | `--EXPR -> EXPR [1439:81]
16078 | | | | `--STRING_LITERAL -> "8, 12" [1439:81]
16079 | | | `--RPAREN -> ) [1439:88]
16080 | | |--COMMA -> , [1439:89]
16081 | | |--EXPR -> EXPR [1440:23]
16082 | | | `--PLUS -> + [1440:23]
16083 | | | |--STRING_LITERAL -> "150:11: " [1440:12]
16084 | | | `--METHOD_CALL -> ( [1440:40]
16085 | | | |--IDENT -> getCheckMessage [1440:25]
16086 | | | |--ELIST -> ELIST [1440:41]
16087 | | | | |--EXPR -> EXPR [1440:41]
16088 | | | | | `--IDENT -> MSG_ERROR [1440:41]
16089 | | | | |--COMMA -> , [1440:50]
16090 | | | | |--EXPR -> EXPR [1440:52]
16091 | | | | | `--STRING_LITERAL -> "method def modifier" [1440:52]
16092 | | | | |--COMMA -> , [1440:73]
16093 | | | | |--EXPR -> EXPR [1440:75]
16094 | | | | | `--NUM_INT -> 10 [1440:75]
16095 | | | | |--COMMA -> , [1440:77]
16096 | | | | `--EXPR -> EXPR [1440:79]
16097 | | | | `--NUM_INT -> 12 [1440:79]
16098 | | | `--RPAREN -> ) [1440:81]
16099 | | |--COMMA -> , [1440:82]
16100 | | |--EXPR -> EXPR [1441:23]
16101 | | | `--PLUS -> + [1441:23]
16102 | | | |--STRING_LITERAL -> "152:11: " [1441:12]
16103 | | | `--METHOD_CALL -> ( [1441:40]
16104 | | | |--IDENT -> getCheckMessage [1441:25]
16105 | | | |--ELIST -> ELIST [1441:41]
16106 | | | | |--EXPR -> EXPR [1441:41]
16107 | | | | | `--IDENT -> MSG_ERROR [1441:41]
16108 | | | | |--COMMA -> , [1441:50]
16109 | | | | |--EXPR -> EXPR [1441:52]
16110 | | | | | `--STRING_LITERAL -> "method def rcurly" [1441:52]
16111 | | | | |--COMMA -> , [1441:71]
16112 | | | | |--EXPR -> EXPR [1441:73]
16113 | | | | | `--NUM_INT -> 10 [1441:73]
16114 | | | | |--COMMA -> , [1441:75]
16115 | | | | `--EXPR -> EXPR [1441:77]
16116 | | | | `--NUM_INT -> 12 [1441:77]
16117 | | | `--RPAREN -> ) [1441:79]
16118 | | |--COMMA -> , [1441:80]
16119 | | |--EXPR -> EXPR [1442:22]
16120 | | | `--PLUS -> + [1442:22]
16121 | | | |--STRING_LITERAL -> "188:1: " [1442:12]
16122 | | | `--METHOD_CALL -> ( [1442:39]
16123 | | | |--IDENT -> getCheckMessage [1442:24]
16124 | | | |--ELIST -> ELIST [1442:40]
16125 | | | | |--EXPR -> EXPR [1442:40]
16126 | | | | | `--IDENT -> MSG_ERROR [1442:40]
16127 | | | | |--COMMA -> , [1442:49]
16128 | | | | |--EXPR -> EXPR [1442:51]
16129 | | | | | `--STRING_LITERAL -> "class" [1442:51]
16130 | | | | |--COMMA -> , [1442:58]
16131 | | | | |--EXPR -> EXPR [1442:60]
16132 | | | | | `--NUM_INT -> 0 [1442:60]
16133 | | | | |--COMMA -> , [1442:61]
16134 | | | | `--EXPR -> EXPR [1442:63]
16135 | | | | `--NUM_INT -> 4 [1442:63]
16136 | | | `--RPAREN -> ) [1442:64]
16137 | | |--COMMA -> , [1442:65]
16138 | | `--RCURLY -> } [1443:8]
16139 | |--SEMI -> ; [1443:9]
16140 | |--EXPR -> EXPR [1444:19]
16141 | | `--METHOD_CALL -> ( [1444:19]
16142 | | |--IDENT -> verifyWarns [1444:8]
16143 | | |--ELIST -> ELIST [1444:20]
16144 | | | |--EXPR -> EXPR [1444:20]
16145 | | | | `--IDENT -> checkConfig [1444:20]
16146 | | | |--COMMA -> , [1444:31]
16147 | | | |--EXPR -> EXPR [1444:33]
16148 | | | | `--IDENT -> fileName [1444:33]
16149 | | | |--COMMA -> , [1444:41]
16150 | | | `--EXPR -> EXPR [1444:43]
16151 | | | `--IDENT -> expected [1444:43]
16152 | | `--RPAREN -> ) [1444:51]
16153 | |--SEMI -> ; [1444:52]
16154 | `--RCURLY -> } [1445:4]
16155 |--METHOD_DEF -> METHOD_DEF [1447:4]
16156 | |--MODIFIERS -> MODIFIERS [1447:4]
16157 | | |--ANNOTATION -> ANNOTATION [1447:4]
16158 | | | |--AT -> @ [1447:4]
16159 | | | `--IDENT -> Test [1447:5]
16160 | | `--LITERAL_PUBLIC -> public [1448:4]
16161 | |--TYPE -> TYPE [1448:11]
16162 | | `--LITERAL_VOID -> void [1448:11]
16163 | |--IDENT -> testInvalidBlockWithChecker [1448:16]
16164 | |--LPAREN -> ( [1448:43]
16165 | |--PARAMETERS -> PARAMETERS [1448:44]
16166 | |--RPAREN -> ) [1448:44]
16167 | |--LITERAL_THROWS -> throws [1449:12]
16168 | | `--IDENT -> Exception [1449:19]
16169 | `--SLIST -> { [1449:29]
16170 | |--VARIABLE_DEF -> VARIABLE_DEF [1450:8]
16171 | | |--MODIFIERS -> MODIFIERS [1450:8]
16172 | | | `--FINAL -> final [1450:8]
16173 | | |--TYPE -> TYPE [1450:14]
16174 | | | `--IDENT -> DefaultConfiguration [1450:14]
16175 | | |--IDENT -> checkConfig [1450:35]
16176 | | `--ASSIGN -> = [1450:47]
16177 | | `--EXPR -> EXPR [1450:67]
16178 | | `--METHOD_CALL -> ( [1450:67]
16179 | | |--IDENT -> createModuleConfig [1450:49]
16180 | | |--ELIST -> ELIST [1450:84]
16181 | | | `--EXPR -> EXPR [1450:84]
16182 | | | `--DOT -> . [1450:84]
16183 | | | |--IDENT -> IndentationCheck [1450:68]
16184 | | | `--LITERAL_CLASS -> class [1450:85]
16185 | | `--RPAREN -> ) [1450:90]
16186 | |--SEMI -> ; [1450:91]
16187 | |--EXPR -> EXPR [1452:32]
16188 | | `--METHOD_CALL -> ( [1452:32]
16189 | | |--DOT -> . [1452:19]
16190 | | | |--IDENT -> checkConfig [1452:8]
16191 | | | `--IDENT -> addAttribute [1452:20]
16192 | | |--ELIST -> ELIST [1452:33]
16193 | | | |--EXPR -> EXPR [1452:33]
16194 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1452:33]
16195 | | | |--COMMA -> , [1452:50]
16196 | | | `--EXPR -> EXPR [1452:52]
16197 | | | `--STRING_LITERAL -> "4" [1452:52]
16198 | | `--RPAREN -> ) [1452:55]
16199 | |--SEMI -> ; [1452:56]
16200 | |--EXPR -> EXPR [1453:32]
16201 | | `--METHOD_CALL -> ( [1453:32]
16202 | | |--DOT -> . [1453:19]
16203 | | | |--IDENT -> checkConfig [1453:8]
16204 | | | `--IDENT -> addAttribute [1453:20]
16205 | | |--ELIST -> ELIST [1453:33]
16206 | | | |--EXPR -> EXPR [1453:33]
16207 | | | | `--STRING_LITERAL -> "basicOffset" [1453:33]
16208 | | | |--COMMA -> , [1453:46]
16209 | | | `--EXPR -> EXPR [1453:48]
16210 | | | `--STRING_LITERAL -> "4" [1453:48]
16211 | | `--RPAREN -> ) [1453:51]
16212 | |--SEMI -> ; [1453:52]
16213 | |--EXPR -> EXPR [1454:32]
16214 | | `--METHOD_CALL -> ( [1454:32]
16215 | | |--DOT -> . [1454:19]
16216 | | | |--IDENT -> checkConfig [1454:8]
16217 | | | `--IDENT -> addAttribute [1454:20]
16218 | | |--ELIST -> ELIST [1454:33]
16219 | | | |--EXPR -> EXPR [1454:33]
16220 | | | | `--STRING_LITERAL -> "braceAdjustment" [1454:33]
16221 | | | |--COMMA -> , [1454:50]
16222 | | | `--EXPR -> EXPR [1454:52]
16223 | | | `--STRING_LITERAL -> "0" [1454:52]
16224 | | `--RPAREN -> ) [1454:55]
16225 | |--SEMI -> ; [1454:56]
16226 | |--EXPR -> EXPR [1455:32]
16227 | | `--METHOD_CALL -> ( [1455:32]
16228 | | |--DOT -> . [1455:19]
16229 | | | |--IDENT -> checkConfig [1455:8]
16230 | | | `--IDENT -> addAttribute [1455:20]
16231 | | |--ELIST -> ELIST [1455:33]
16232 | | | |--EXPR -> EXPR [1455:33]
16233 | | | | `--STRING_LITERAL -> "caseIndent" [1455:33]
16234 | | | |--COMMA -> , [1455:45]
16235 | | | `--EXPR -> EXPR [1455:47]
16236 | | | `--STRING_LITERAL -> "4" [1455:47]
16237 | | `--RPAREN -> ) [1455:50]
16238 | |--SEMI -> ; [1455:51]
16239 | |--EXPR -> EXPR [1456:32]
16240 | | `--METHOD_CALL -> ( [1456:32]
16241 | | |--DOT -> . [1456:19]
16242 | | | |--IDENT -> checkConfig [1456:8]
16243 | | | `--IDENT -> addAttribute [1456:20]
16244 | | |--ELIST -> ELIST [1456:33]
16245 | | | |--EXPR -> EXPR [1456:33]
16246 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1456:33]
16247 | | | |--COMMA -> , [1456:55]
16248 | | | `--EXPR -> EXPR [1456:57]
16249 | | | `--STRING_LITERAL -> "false" [1456:57]
16250 | | `--RPAREN -> ) [1456:64]
16251 | |--SEMI -> ; [1456:65]
16252 | |--EXPR -> EXPR [1457:32]
16253 | | `--METHOD_CALL -> ( [1457:32]
16254 | | |--DOT -> . [1457:19]
16255 | | | |--IDENT -> checkConfig [1457:8]
16256 | | | `--IDENT -> addAttribute [1457:20]
16257 | | |--ELIST -> ELIST [1457:33]
16258 | | | |--EXPR -> EXPR [1457:33]
16259 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1457:33]
16260 | | | |--COMMA -> , [1457:58]
16261 | | | `--EXPR -> EXPR [1457:60]
16262 | | | `--STRING_LITERAL -> "4" [1457:60]
16263 | | `--RPAREN -> ) [1457:63]
16264 | |--SEMI -> ; [1457:64]
16265 | |--EXPR -> EXPR [1458:32]
16266 | | `--METHOD_CALL -> ( [1458:32]
16267 | | |--DOT -> . [1458:19]
16268 | | | |--IDENT -> checkConfig [1458:8]
16269 | | | `--IDENT -> addAttribute [1458:20]
16270 | | |--ELIST -> ELIST [1458:33]
16271 | | | |--EXPR -> EXPR [1458:33]
16272 | | | | `--STRING_LITERAL -> "tabWidth" [1458:33]
16273 | | | |--COMMA -> , [1458:43]
16274 | | | `--EXPR -> EXPR [1458:45]
16275 | | | `--STRING_LITERAL -> "4" [1458:45]
16276 | | `--RPAREN -> ) [1458:48]
16277 | |--SEMI -> ; [1458:49]
16278 | |--EXPR -> EXPR [1459:32]
16279 | | `--METHOD_CALL -> ( [1459:32]
16280 | | |--DOT -> . [1459:19]
16281 | | | |--IDENT -> checkConfig [1459:8]
16282 | | | `--IDENT -> addAttribute [1459:20]
16283 | | |--ELIST -> ELIST [1459:33]
16284 | | | |--EXPR -> EXPR [1459:33]
16285 | | | | `--STRING_LITERAL -> "throwsIndent" [1459:33]
16286 | | | |--COMMA -> , [1459:47]
16287 | | | `--EXPR -> EXPR [1459:49]
16288 | | | `--STRING_LITERAL -> "4" [1459:49]
16289 | | `--RPAREN -> ) [1459:52]
16290 | |--SEMI -> ; [1459:53]
16291 | |--VARIABLE_DEF -> VARIABLE_DEF [1460:8]
16292 | | |--MODIFIERS -> MODIFIERS [1460:8]
16293 | | | `--FINAL -> final [1460:8]
16294 | | |--TYPE -> TYPE [1460:14]
16295 | | | `--IDENT -> String [1460:14]
16296 | | |--IDENT -> fileName [1460:21]
16297 | | `--ASSIGN -> = [1460:30]
16298 | | `--EXPR -> EXPR [1460:39]
16299 | | `--METHOD_CALL -> ( [1460:39]
16300 | | |--IDENT -> getPath [1460:32]
16301 | | |--ELIST -> ELIST [1460:40]
16302 | | | `--EXPR -> EXPR [1460:40]
16303 | | | `--STRING_LITERAL -> "InputIndentationInvalidBlockIndent.java" [1460:40]
16304 | | `--RPAREN -> ) [1460:81]
16305 | |--SEMI -> ; [1460:82]
16306 | |--VARIABLE_DEF -> VARIABLE_DEF [1461:8]
16307 | | |--MODIFIERS -> MODIFIERS [1461:8]
16308 | | | `--FINAL -> final [1461:8]
16309 | | |--TYPE -> TYPE [1461:20]
16310 | | | `--ARRAY_DECLARATOR -> [ [1461:20]
16311 | | | |--IDENT -> String [1461:14]
16312 | | | `--RBRACK -> ] [1461:21]
16313 | | |--IDENT -> expected [1461:23]
16314 | | `--ASSIGN -> = [1461:32]
16315 | | `--ARRAY_INIT -> { [1461:34]
16316 | | |--EXPR -> EXPR [1462:21]
16317 | | | `--PLUS -> + [1462:21]
16318 | | | |--STRING_LITERAL -> "26:8: " [1462:12]
16319 | | | `--METHOD_CALL -> ( [1462:38]
16320 | | | |--IDENT -> getCheckMessage [1462:23]
16321 | | | |--ELIST -> ELIST [1462:39]
16322 | | | | |--EXPR -> EXPR [1462:39]
16323 | | | | | `--IDENT -> MSG_ERROR [1462:39]
16324 | | | | |--COMMA -> , [1462:48]
16325 | | | | |--EXPR -> EXPR [1462:50]
16326 | | | | | `--STRING_LITERAL -> "block lcurly" [1462:50]
16327 | | | | |--COMMA -> , [1462:64]
16328 | | | | |--EXPR -> EXPR [1462:66]
16329 | | | | | `--NUM_INT -> 7 [1462:66]
16330 | | | | |--COMMA -> , [1462:67]
16331 | | | | `--EXPR -> EXPR [1462:69]
16332 | | | | `--NUM_INT -> 8 [1462:69]
16333 | | | `--RPAREN -> ) [1462:70]
16334 | | |--COMMA -> , [1462:71]
16335 | | |--EXPR -> EXPR [1463:22]
16336 | | | `--PLUS -> + [1463:22]
16337 | | | |--STRING_LITERAL -> "27:10: " [1463:12]
16338 | | | `--METHOD_CALL -> ( [1463:39]
16339 | | | |--IDENT -> getCheckMessage [1463:24]
16340 | | | |--ELIST -> ELIST [1463:40]
16341 | | | | |--EXPR -> EXPR [1463:40]
16342 | | | | | `--IDENT -> MSG_ERROR [1463:40]
16343 | | | | |--COMMA -> , [1463:49]
16344 | | | | |--EXPR -> EXPR [1463:51]
16345 | | | | | `--STRING_LITERAL -> "block lcurly" [1463:51]
16346 | | | | |--COMMA -> , [1463:65]
16347 | | | | |--EXPR -> EXPR [1463:67]
16348 | | | | | `--NUM_INT -> 9 [1463:67]
16349 | | | | |--COMMA -> , [1463:68]
16350 | | | | `--EXPR -> EXPR [1463:70]
16351 | | | | `--NUM_INT -> 8 [1463:70]
16352 | | | `--RPAREN -> ) [1463:71]
16353 | | |--COMMA -> , [1463:72]
16354 | | |--EXPR -> EXPR [1464:22]
16355 | | | `--PLUS -> + [1464:22]
16356 | | | |--STRING_LITERAL -> "29:10: " [1464:12]
16357 | | | `--METHOD_CALL -> ( [1464:39]
16358 | | | |--IDENT -> getCheckMessage [1464:24]
16359 | | | |--ELIST -> ELIST [1464:40]
16360 | | | | |--EXPR -> EXPR [1464:40]
16361 | | | | | `--IDENT -> MSG_ERROR [1464:40]
16362 | | | | |--COMMA -> , [1464:49]
16363 | | | | |--EXPR -> EXPR [1464:51]
16364 | | | | | `--STRING_LITERAL -> "block lcurly" [1464:51]
16365 | | | | |--COMMA -> , [1464:65]
16366 | | | | |--EXPR -> EXPR [1464:67]
16367 | | | | | `--NUM_INT -> 9 [1464:67]
16368 | | | | |--COMMA -> , [1464:68]
16369 | | | | `--EXPR -> EXPR [1464:70]
16370 | | | | `--NUM_INT -> 8 [1464:70]
16371 | | | `--RPAREN -> ) [1464:71]
16372 | | |--COMMA -> , [1464:72]
16373 | | |--EXPR -> EXPR [1465:21]
16374 | | | `--PLUS -> + [1465:21]
16375 | | | |--STRING_LITERAL -> "30:8: " [1465:12]
16376 | | | `--METHOD_CALL -> ( [1465:38]
16377 | | | |--IDENT -> getCheckMessage [1465:23]
16378 | | | |--ELIST -> ELIST [1465:39]
16379 | | | | |--EXPR -> EXPR [1465:39]
16380 | | | | | `--IDENT -> MSG_ERROR [1465:39]
16381 | | | | |--COMMA -> , [1465:48]
16382 | | | | |--EXPR -> EXPR [1465:50]
16383 | | | | | `--STRING_LITERAL -> "block rcurly" [1465:50]
16384 | | | | |--COMMA -> , [1465:64]
16385 | | | | |--EXPR -> EXPR [1465:66]
16386 | | | | | `--NUM_INT -> 7 [1465:66]
16387 | | | | |--COMMA -> , [1465:67]
16388 | | | | `--EXPR -> EXPR [1465:69]
16389 | | | | `--NUM_INT -> 8 [1465:69]
16390 | | | `--RPAREN -> ) [1465:70]
16391 | | |--COMMA -> , [1465:71]
16392 | | |--EXPR -> EXPR [1466:21]
16393 | | | `--PLUS -> + [1466:21]
16394 | | | |--STRING_LITERAL -> "32:7: " [1466:12]
16395 | | | `--METHOD_CALL -> ( [1466:38]
16396 | | | |--IDENT -> getCheckMessage [1466:23]
16397 | | | |--ELIST -> ELIST [1466:39]
16398 | | | | |--EXPR -> EXPR [1466:39]
16399 | | | | | `--IDENT -> MSG_ERROR [1466:39]
16400 | | | | |--COMMA -> , [1466:48]
16401 | | | | |--EXPR -> EXPR [1466:50]
16402 | | | | | `--STRING_LITERAL -> "block lcurly" [1466:50]
16403 | | | | |--COMMA -> , [1466:64]
16404 | | | | |--EXPR -> EXPR [1466:66]
16405 | | | | | `--NUM_INT -> 6 [1466:66]
16406 | | | | |--COMMA -> , [1466:67]
16407 | | | | `--EXPR -> EXPR [1466:69]
16408 | | | | `--NUM_INT -> 8 [1466:69]
16409 | | | `--RPAREN -> ) [1466:70]
16410 | | |--COMMA -> , [1466:71]
16411 | | |--EXPR -> EXPR [1467:21]
16412 | | | `--PLUS -> + [1467:21]
16413 | | | |--STRING_LITERAL -> "34:7: " [1467:12]
16414 | | | `--METHOD_CALL -> ( [1467:38]
16415 | | | |--IDENT -> getCheckMessage [1467:23]
16416 | | | |--ELIST -> ELIST [1467:39]
16417 | | | | |--EXPR -> EXPR [1467:39]
16418 | | | | | `--IDENT -> MSG_ERROR [1467:39]
16419 | | | | |--COMMA -> , [1467:48]
16420 | | | | |--EXPR -> EXPR [1467:50]
16421 | | | | | `--STRING_LITERAL -> "block rcurly" [1467:50]
16422 | | | | |--COMMA -> , [1467:64]
16423 | | | | |--EXPR -> EXPR [1467:66]
16424 | | | | | `--NUM_INT -> 6 [1467:66]
16425 | | | | |--COMMA -> , [1467:67]
16426 | | | | `--EXPR -> EXPR [1467:69]
16427 | | | | `--NUM_INT -> 8 [1467:69]
16428 | | | `--RPAREN -> ) [1467:70]
16429 | | |--COMMA -> , [1467:71]
16430 | | |--EXPR -> EXPR [1468:21]
16431 | | | `--PLUS -> + [1468:21]
16432 | | | |--STRING_LITERAL -> "35:7: " [1468:12]
16433 | | | `--METHOD_CALL -> ( [1468:38]
16434 | | | |--IDENT -> getCheckMessage [1468:23]
16435 | | | |--ELIST -> ELIST [1468:39]
16436 | | | | |--EXPR -> EXPR [1468:39]
16437 | | | | | `--IDENT -> MSG_ERROR [1468:39]
16438 | | | | |--COMMA -> , [1468:48]
16439 | | | | |--EXPR -> EXPR [1468:50]
16440 | | | | | `--STRING_LITERAL -> "block lcurly" [1468:50]
16441 | | | | |--COMMA -> , [1468:64]
16442 | | | | |--EXPR -> EXPR [1468:66]
16443 | | | | | `--NUM_INT -> 6 [1468:66]
16444 | | | | |--COMMA -> , [1468:67]
16445 | | | | `--EXPR -> EXPR [1468:69]
16446 | | | | `--NUM_INT -> 8 [1468:69]
16447 | | | `--RPAREN -> ) [1468:70]
16448 | | |--COMMA -> , [1468:71]
16449 | | |--EXPR -> EXPR [1469:22]
16450 | | | `--PLUS -> + [1469:22]
16451 | | | |--STRING_LITERAL -> "38:10: " [1469:12]
16452 | | | `--METHOD_CALL -> ( [1469:39]
16453 | | | |--IDENT -> getCheckMessage [1469:24]
16454 | | | |--ELIST -> ELIST [1469:40]
16455 | | | | |--EXPR -> EXPR [1469:40]
16456 | | | | | `--IDENT -> MSG_ERROR [1469:40]
16457 | | | | |--COMMA -> , [1469:49]
16458 | | | | |--EXPR -> EXPR [1469:51]
16459 | | | | | `--STRING_LITERAL -> "block lcurly" [1469:51]
16460 | | | | |--COMMA -> , [1469:65]
16461 | | | | |--EXPR -> EXPR [1469:67]
16462 | | | | | `--NUM_INT -> 9 [1469:67]
16463 | | | | |--COMMA -> , [1469:68]
16464 | | | | `--EXPR -> EXPR [1469:70]
16465 | | | | `--NUM_INT -> 8 [1469:70]
16466 | | | `--RPAREN -> ) [1469:71]
16467 | | |--COMMA -> , [1469:72]
16468 | | |--EXPR -> EXPR [1470:22]
16469 | | | `--PLUS -> + [1470:22]
16470 | | | |--STRING_LITERAL -> "39:14: " [1470:12]
16471 | | | `--METHOD_CALL -> ( [1470:39]
16472 | | | |--IDENT -> getCheckMessage [1470:24]
16473 | | | |--ELIST -> ELIST [1470:40]
16474 | | | | |--EXPR -> EXPR [1470:40]
16475 | | | | | `--IDENT -> MSG_CHILD_ERROR [1470:40]
16476 | | | | |--COMMA -> , [1470:55]
16477 | | | | |--EXPR -> EXPR [1470:57]
16478 | | | | | `--STRING_LITERAL -> "block" [1470:57]
16479 | | | | |--COMMA -> , [1470:64]
16480 | | | | |--EXPR -> EXPR [1470:66]
16481 | | | | | `--NUM_INT -> 13 [1470:66]
16482 | | | | |--COMMA -> , [1470:68]
16483 | | | | `--EXPR -> EXPR [1470:70]
16484 | | | | `--NUM_INT -> 12 [1470:70]
16485 | | | `--RPAREN -> ) [1470:72]
16486 | | |--COMMA -> , [1470:73]
16487 | | |--EXPR -> EXPR [1471:22]
16488 | | | `--PLUS -> + [1471:22]
16489 | | | |--STRING_LITERAL -> "41:14: " [1471:12]
16490 | | | `--METHOD_CALL -> ( [1471:39]
16491 | | | |--IDENT -> getCheckMessage [1471:24]
16492 | | | |--ELIST -> ELIST [1471:40]
16493 | | | | |--EXPR -> EXPR [1471:40]
16494 | | | | | `--IDENT -> MSG_CHILD_ERROR [1471:40]
16495 | | | | |--COMMA -> , [1471:55]
16496 | | | | |--EXPR -> EXPR [1471:57]
16497 | | | | | `--STRING_LITERAL -> "block" [1471:57]
16498 | | | | |--COMMA -> , [1471:64]
16499 | | | | |--EXPR -> EXPR [1471:66]
16500 | | | | | `--NUM_INT -> 13 [1471:66]
16501 | | | | |--COMMA -> , [1471:68]
16502 | | | | `--EXPR -> EXPR [1471:70]
16503 | | | | `--NUM_INT -> 12 [1471:70]
16504 | | | `--RPAREN -> ) [1471:72]
16505 | | |--COMMA -> , [1471:73]
16506 | | |--EXPR -> EXPR [1472:22]
16507 | | | `--PLUS -> + [1472:22]
16508 | | | |--STRING_LITERAL -> "42:10: " [1472:12]
16509 | | | `--METHOD_CALL -> ( [1472:39]
16510 | | | |--IDENT -> getCheckMessage [1472:24]
16511 | | | |--ELIST -> ELIST [1472:40]
16512 | | | | |--EXPR -> EXPR [1472:40]
16513 | | | | | `--IDENT -> MSG_ERROR [1472:40]
16514 | | | | |--COMMA -> , [1472:49]
16515 | | | | |--EXPR -> EXPR [1472:51]
16516 | | | | | `--STRING_LITERAL -> "block rcurly" [1472:51]
16517 | | | | |--COMMA -> , [1472:65]
16518 | | | | |--EXPR -> EXPR [1472:67]
16519 | | | | | `--NUM_INT -> 9 [1472:67]
16520 | | | | |--COMMA -> , [1472:68]
16521 | | | | `--EXPR -> EXPR [1472:70]
16522 | | | | `--NUM_INT -> 8 [1472:70]
16523 | | | `--RPAREN -> ) [1472:71]
16524 | | |--COMMA -> , [1472:72]
16525 | | |--EXPR -> EXPR [1473:21]
16526 | | | `--PLUS -> + [1473:21]
16527 | | | |--STRING_LITERAL -> "45:7: " [1473:12]
16528 | | | `--METHOD_CALL -> ( [1473:38]
16529 | | | |--IDENT -> getCheckMessage [1473:23]
16530 | | | |--ELIST -> ELIST [1473:39]
16531 | | | | |--EXPR -> EXPR [1473:39]
16532 | | | | | `--IDENT -> MSG_ERROR [1473:39]
16533 | | | | |--COMMA -> , [1473:48]
16534 | | | | |--EXPR -> EXPR [1473:50]
16535 | | | | | `--STRING_LITERAL -> "block lcurly" [1473:50]
16536 | | | | |--COMMA -> , [1473:64]
16537 | | | | |--EXPR -> EXPR [1473:66]
16538 | | | | | `--NUM_INT -> 6 [1473:66]
16539 | | | | |--COMMA -> , [1473:67]
16540 | | | | `--EXPR -> EXPR [1473:69]
16541 | | | | `--NUM_INT -> 8 [1473:69]
16542 | | | `--RPAREN -> ) [1473:70]
16543 | | |--COMMA -> , [1473:71]
16544 | | |--EXPR -> EXPR [1474:22]
16545 | | | `--PLUS -> + [1474:22]
16546 | | | |--STRING_LITERAL -> "46:11: " [1474:12]
16547 | | | `--METHOD_CALL -> ( [1474:39]
16548 | | | |--IDENT -> getCheckMessage [1474:24]
16549 | | | |--ELIST -> ELIST [1474:40]
16550 | | | | |--EXPR -> EXPR [1474:40]
16551 | | | | | `--IDENT -> MSG_CHILD_ERROR [1474:40]
16552 | | | | |--COMMA -> , [1474:55]
16553 | | | | |--EXPR -> EXPR [1474:57]
16554 | | | | | `--STRING_LITERAL -> "block" [1474:57]
16555 | | | | |--COMMA -> , [1474:64]
16556 | | | | |--EXPR -> EXPR [1474:66]
16557 | | | | | `--NUM_INT -> 10 [1474:66]
16558 | | | | |--COMMA -> , [1474:68]
16559 | | | | `--EXPR -> EXPR [1474:70]
16560 | | | | `--NUM_INT -> 12 [1474:70]
16561 | | | `--RPAREN -> ) [1474:72]
16562 | | |--COMMA -> , [1474:73]
16563 | | |--EXPR -> EXPR [1475:22]
16564 | | | `--PLUS -> + [1475:22]
16565 | | | |--STRING_LITERAL -> "48:11: " [1475:12]
16566 | | | `--METHOD_CALL -> ( [1475:39]
16567 | | | |--IDENT -> getCheckMessage [1475:24]
16568 | | | |--ELIST -> ELIST [1475:40]
16569 | | | | |--EXPR -> EXPR [1475:40]
16570 | | | | | `--IDENT -> MSG_CHILD_ERROR [1475:40]
16571 | | | | |--COMMA -> , [1475:55]
16572 | | | | |--EXPR -> EXPR [1475:57]
16573 | | | | | `--STRING_LITERAL -> "block" [1475:57]
16574 | | | | |--COMMA -> , [1475:64]
16575 | | | | |--EXPR -> EXPR [1475:66]
16576 | | | | | `--NUM_INT -> 10 [1475:66]
16577 | | | | |--COMMA -> , [1475:68]
16578 | | | | `--EXPR -> EXPR [1475:70]
16579 | | | | `--NUM_INT -> 12 [1475:70]
16580 | | | `--RPAREN -> ) [1475:72]
16581 | | |--COMMA -> , [1475:73]
16582 | | |--EXPR -> EXPR [1476:21]
16583 | | | `--PLUS -> + [1476:21]
16584 | | | |--STRING_LITERAL -> "49:7: " [1476:12]
16585 | | | `--METHOD_CALL -> ( [1476:38]
16586 | | | |--IDENT -> getCheckMessage [1476:23]
16587 | | | |--ELIST -> ELIST [1476:39]
16588 | | | | |--EXPR -> EXPR [1476:39]
16589 | | | | | `--IDENT -> MSG_ERROR [1476:39]
16590 | | | | |--COMMA -> , [1476:48]
16591 | | | | |--EXPR -> EXPR [1476:50]
16592 | | | | | `--STRING_LITERAL -> "block rcurly" [1476:50]
16593 | | | | |--COMMA -> , [1476:64]
16594 | | | | |--EXPR -> EXPR [1476:66]
16595 | | | | | `--NUM_INT -> 6 [1476:66]
16596 | | | | |--COMMA -> , [1476:67]
16597 | | | | `--EXPR -> EXPR [1476:69]
16598 | | | | `--NUM_INT -> 8 [1476:69]
16599 | | | `--RPAREN -> ) [1476:70]
16600 | | |--COMMA -> , [1476:71]
16601 | | |--EXPR -> EXPR [1477:21]
16602 | | | `--PLUS -> + [1477:21]
16603 | | | |--STRING_LITERAL -> "52:7: " [1477:12]
16604 | | | `--METHOD_CALL -> ( [1477:38]
16605 | | | |--IDENT -> getCheckMessage [1477:23]
16606 | | | |--ELIST -> ELIST [1477:39]
16607 | | | | |--EXPR -> EXPR [1477:39]
16608 | | | | | `--IDENT -> MSG_ERROR [1477:39]
16609 | | | | |--COMMA -> , [1477:48]
16610 | | | | |--EXPR -> EXPR [1477:50]
16611 | | | | | `--STRING_LITERAL -> "block lcurly" [1477:50]
16612 | | | | |--COMMA -> , [1477:64]
16613 | | | | |--EXPR -> EXPR [1477:66]
16614 | | | | | `--NUM_INT -> 6 [1477:66]
16615 | | | | |--COMMA -> , [1477:67]
16616 | | | | `--EXPR -> EXPR [1477:69]
16617 | | | | `--NUM_INT -> 8 [1477:69]
16618 | | | `--RPAREN -> ) [1477:70]
16619 | | |--COMMA -> , [1477:71]
16620 | | |--EXPR -> EXPR [1478:22]
16621 | | | `--PLUS -> + [1478:22]
16622 | | | |--STRING_LITERAL -> "55:11: " [1478:12]
16623 | | | `--METHOD_CALL -> ( [1478:39]
16624 | | | |--IDENT -> getCheckMessage [1478:24]
16625 | | | |--ELIST -> ELIST [1478:40]
16626 | | | | |--EXPR -> EXPR [1478:40]
16627 | | | | | `--IDENT -> MSG_CHILD_ERROR [1478:40]
16628 | | | | |--COMMA -> , [1478:55]
16629 | | | | |--EXPR -> EXPR [1478:57]
16630 | | | | | `--STRING_LITERAL -> "block" [1478:57]
16631 | | | | |--COMMA -> , [1478:64]
16632 | | | | |--EXPR -> EXPR [1478:66]
16633 | | | | | `--NUM_INT -> 10 [1478:66]
16634 | | | | |--COMMA -> , [1478:68]
16635 | | | | `--EXPR -> EXPR [1478:70]
16636 | | | | `--NUM_INT -> 12 [1478:70]
16637 | | | `--RPAREN -> ) [1478:72]
16638 | | |--COMMA -> , [1478:73]
16639 | | |--EXPR -> EXPR [1479:22]
16640 | | | `--PLUS -> + [1479:22]
16641 | | | |--STRING_LITERAL -> "59:11: " [1479:12]
16642 | | | `--METHOD_CALL -> ( [1479:39]
16643 | | | |--IDENT -> getCheckMessage [1479:24]
16644 | | | |--ELIST -> ELIST [1479:40]
16645 | | | | |--EXPR -> EXPR [1479:40]
16646 | | | | | `--IDENT -> MSG_ERROR [1479:40]
16647 | | | | |--COMMA -> , [1479:49]
16648 | | | | |--EXPR -> EXPR [1479:51]
16649 | | | | | `--STRING_LITERAL -> "block lcurly" [1479:51]
16650 | | | | |--COMMA -> , [1479:65]
16651 | | | | |--EXPR -> EXPR [1479:67]
16652 | | | | | `--NUM_INT -> 10 [1479:67]
16653 | | | | |--COMMA -> , [1479:69]
16654 | | | | `--EXPR -> EXPR [1479:71]
16655 | | | | `--NUM_INT -> 12 [1479:71]
16656 | | | `--RPAREN -> ) [1479:73]
16657 | | |--COMMA -> , [1479:74]
16658 | | |--EXPR -> EXPR [1480:22]
16659 | | | `--PLUS -> + [1480:22]
16660 | | | |--STRING_LITERAL -> "63:11: " [1480:12]
16661 | | | `--METHOD_CALL -> ( [1480:39]
16662 | | | |--IDENT -> getCheckMessage [1480:24]
16663 | | | |--ELIST -> ELIST [1480:40]
16664 | | | | |--EXPR -> EXPR [1480:40]
16665 | | | | | `--IDENT -> MSG_ERROR [1480:40]
16666 | | | | |--COMMA -> , [1480:49]
16667 | | | | |--EXPR -> EXPR [1480:51]
16668 | | | | | `--STRING_LITERAL -> "block rcurly" [1480:51]
16669 | | | | |--COMMA -> , [1480:65]
16670 | | | | |--EXPR -> EXPR [1480:67]
16671 | | | | | `--NUM_INT -> 10 [1480:67]
16672 | | | | |--COMMA -> , [1480:69]
16673 | | | | `--EXPR -> EXPR [1480:71]
16674 | | | | `--NUM_INT -> 12 [1480:71]
16675 | | | `--RPAREN -> ) [1480:73]
16676 | | |--COMMA -> , [1480:74]
16677 | | |--EXPR -> EXPR [1481:22]
16678 | | | `--PLUS -> + [1481:22]
16679 | | | |--STRING_LITERAL -> "68:11: " [1481:12]
16680 | | | `--METHOD_CALL -> ( [1481:39]
16681 | | | |--IDENT -> getCheckMessage [1481:24]
16682 | | | |--ELIST -> ELIST [1481:40]
16683 | | | | |--EXPR -> EXPR [1481:40]
16684 | | | | | `--IDENT -> MSG_CHILD_ERROR [1481:40]
16685 | | | | |--COMMA -> , [1481:55]
16686 | | | | |--EXPR -> EXPR [1481:57]
16687 | | | | | `--STRING_LITERAL -> "block" [1481:57]
16688 | | | | |--COMMA -> , [1481:64]
16689 | | | | |--EXPR -> EXPR [1481:66]
16690 | | | | | `--NUM_INT -> 10 [1481:66]
16691 | | | | |--COMMA -> , [1481:68]
16692 | | | | `--EXPR -> EXPR [1481:70]
16693 | | | | `--NUM_INT -> 12 [1481:70]
16694 | | | `--RPAREN -> ) [1481:72]
16695 | | |--COMMA -> , [1481:73]
16696 | | |--EXPR -> EXPR [1482:22]
16697 | | | `--PLUS -> + [1482:22]
16698 | | | |--STRING_LITERAL -> "70:11: " [1482:12]
16699 | | | `--METHOD_CALL -> ( [1482:39]
16700 | | | |--IDENT -> getCheckMessage [1482:24]
16701 | | | |--ELIST -> ELIST [1482:40]
16702 | | | | |--EXPR -> EXPR [1482:40]
16703 | | | | | `--IDENT -> MSG_ERROR [1482:40]
16704 | | | | |--COMMA -> , [1482:49]
16705 | | | | |--EXPR -> EXPR [1482:51]
16706 | | | | | `--STRING_LITERAL -> "block lcurly" [1482:51]
16707 | | | | |--COMMA -> , [1482:65]
16708 | | | | |--EXPR -> EXPR [1482:67]
16709 | | | | | `--NUM_INT -> 10 [1482:67]
16710 | | | | |--COMMA -> , [1482:69]
16711 | | | | `--EXPR -> EXPR [1482:71]
16712 | | | | `--NUM_INT -> 12 [1482:71]
16713 | | | `--RPAREN -> ) [1482:73]
16714 | | |--COMMA -> , [1482:74]
16715 | | |--EXPR -> EXPR [1483:22]
16716 | | | `--PLUS -> + [1483:22]
16717 | | | |--STRING_LITERAL -> "71:15: " [1483:12]
16718 | | | `--METHOD_CALL -> ( [1483:39]
16719 | | | |--IDENT -> getCheckMessage [1483:24]
16720 | | | |--ELIST -> ELIST [1483:40]
16721 | | | | |--EXPR -> EXPR [1483:40]
16722 | | | | | `--IDENT -> MSG_CHILD_ERROR [1483:40]
16723 | | | | |--COMMA -> , [1483:55]
16724 | | | | |--EXPR -> EXPR [1483:57]
16725 | | | | | `--STRING_LITERAL -> "block" [1483:57]
16726 | | | | |--COMMA -> , [1483:64]
16727 | | | | |--EXPR -> EXPR [1483:66]
16728 | | | | | `--NUM_INT -> 14 [1483:66]
16729 | | | | |--COMMA -> , [1483:68]
16730 | | | | `--EXPR -> EXPR [1483:70]
16731 | | | | `--NUM_INT -> 16 [1483:70]
16732 | | | `--RPAREN -> ) [1483:72]
16733 | | |--COMMA -> , [1483:73]
16734 | | |--EXPR -> EXPR [1484:22]
16735 | | | `--PLUS -> + [1484:22]
16736 | | | |--STRING_LITERAL -> "86:11: " [1484:12]
16737 | | | `--METHOD_CALL -> ( [1484:39]
16738 | | | |--IDENT -> getCheckMessage [1484:24]
16739 | | | |--ELIST -> ELIST [1484:40]
16740 | | | | |--EXPR -> EXPR [1484:40]
16741 | | | | | `--IDENT -> MSG_ERROR [1484:40]
16742 | | | | |--COMMA -> , [1484:49]
16743 | | | | |--EXPR -> EXPR [1484:51]
16744 | | | | | `--STRING_LITERAL -> "block rcurly" [1484:51]
16745 | | | | |--COMMA -> , [1484:65]
16746 | | | | |--EXPR -> EXPR [1484:67]
16747 | | | | | `--NUM_INT -> 10 [1484:67]
16748 | | | | |--COMMA -> , [1484:69]
16749 | | | | `--EXPR -> EXPR [1484:71]
16750 | | | | `--NUM_INT -> 12 [1484:71]
16751 | | | `--RPAREN -> ) [1484:73]
16752 | | |--COMMA -> , [1484:74]
16753 | | |--EXPR -> EXPR [1485:21]
16754 | | | `--PLUS -> + [1485:21]
16755 | | | |--STRING_LITERAL -> "95:3: " [1485:12]
16756 | | | `--METHOD_CALL -> ( [1485:38]
16757 | | | |--IDENT -> getCheckMessage [1485:23]
16758 | | | |--ELIST -> ELIST [1485:39]
16759 | | | | |--EXPR -> EXPR [1485:39]
16760 | | | | | `--IDENT -> MSG_ERROR [1485:39]
16761 | | | | |--COMMA -> , [1485:48]
16762 | | | | |--EXPR -> EXPR [1485:50]
16763 | | | | | `--STRING_LITERAL -> "static initialization" [1485:50]
16764 | | | | |--COMMA -> , [1485:73]
16765 | | | | |--EXPR -> EXPR [1485:75]
16766 | | | | | `--NUM_INT -> 2 [1485:75]
16767 | | | | |--COMMA -> , [1485:76]
16768 | | | | `--EXPR -> EXPR [1485:78]
16769 | | | | `--NUM_INT -> 4 [1485:78]
16770 | | | `--RPAREN -> ) [1485:79]
16771 | | |--COMMA -> , [1485:80]
16772 | | |--EXPR -> EXPR [1486:21]
16773 | | | `--PLUS -> + [1486:21]
16774 | | | |--STRING_LITERAL -> "96:7: " [1486:12]
16775 | | | `--METHOD_CALL -> ( [1486:38]
16776 | | | |--IDENT -> getCheckMessage [1486:23]
16777 | | | |--ELIST -> ELIST [1486:39]
16778 | | | | |--EXPR -> EXPR [1486:39]
16779 | | | | | `--IDENT -> MSG_ERROR [1486:39]
16780 | | | | |--COMMA -> , [1486:48]
16781 | | | | |--EXPR -> EXPR [1486:50]
16782 | | | | | `--STRING_LITERAL -> "static initialization" [1486:50]
16783 | | | | |--COMMA -> , [1486:73]
16784 | | | | |--EXPR -> EXPR [1486:75]
16785 | | | | | `--NUM_INT -> 6 [1486:75]
16786 | | | | |--COMMA -> , [1486:76]
16787 | | | | `--EXPR -> EXPR [1486:78]
16788 | | | | `--NUM_INT -> 4 [1486:78]
16789 | | | `--RPAREN -> ) [1486:79]
16790 | | |--COMMA -> , [1486:80]
16791 | | |--EXPR -> EXPR [1487:22]
16792 | | | `--PLUS -> + [1487:22]
16793 | | | |--STRING_LITERAL -> "100:8: " [1487:12]
16794 | | | `--METHOD_CALL -> ( [1487:39]
16795 | | | |--IDENT -> getCheckMessage [1487:24]
16796 | | | |--ELIST -> ELIST [1487:40]
16797 | | | | |--EXPR -> EXPR [1487:40]
16798 | | | | | `--IDENT -> MSG_CHILD_ERROR [1487:40]
16799 | | | | |--COMMA -> , [1487:55]
16800 | | | | |--EXPR -> EXPR [1487:57]
16801 | | | | | `--STRING_LITERAL -> "static initialization" [1487:57]
16802 | | | | |--COMMA -> , [1487:80]
16803 | | | | |--EXPR -> EXPR [1487:82]
16804 | | | | | `--NUM_INT -> 7 [1487:82]
16805 | | | | |--COMMA -> , [1487:83]
16806 | | | | `--EXPR -> EXPR [1487:85]
16807 | | | | `--NUM_INT -> 8 [1487:85]
16808 | | | `--RPAREN -> ) [1487:86]
16809 | | |--COMMA -> , [1487:87]
16810 | | |--EXPR -> EXPR [1488:22]
16811 | | | `--PLUS -> + [1488:22]
16812 | | | |--STRING_LITERAL -> "103:7: " [1488:12]
16813 | | | `--METHOD_CALL -> ( [1488:39]
16814 | | | |--IDENT -> getCheckMessage [1488:24]
16815 | | | |--ELIST -> ELIST [1488:40]
16816 | | | | |--EXPR -> EXPR [1488:40]
16817 | | | | | `--IDENT -> MSG_ERROR [1488:40]
16818 | | | | |--COMMA -> , [1488:49]
16819 | | | | |--EXPR -> EXPR [1488:51]
16820 | | | | | `--STRING_LITERAL -> "static initialization" [1488:51]
16821 | | | | |--COMMA -> , [1488:74]
16822 | | | | |--EXPR -> EXPR [1488:76]
16823 | | | | | `--NUM_INT -> 6 [1488:76]
16824 | | | | |--COMMA -> , [1488:77]
16825 | | | | `--EXPR -> EXPR [1488:79]
16826 | | | | `--NUM_INT -> 4 [1488:79]
16827 | | | `--RPAREN -> ) [1488:80]
16828 | | |--COMMA -> , [1488:81]
16829 | | |--EXPR -> EXPR [1489:22]
16830 | | | `--PLUS -> + [1489:22]
16831 | | | |--STRING_LITERAL -> "105:3: " [1489:12]
16832 | | | `--METHOD_CALL -> ( [1489:39]
16833 | | | |--IDENT -> getCheckMessage [1489:24]
16834 | | | |--ELIST -> ELIST [1489:40]
16835 | | | | |--EXPR -> EXPR [1489:40]
16836 | | | | | `--IDENT -> MSG_ERROR [1489:40]
16837 | | | | |--COMMA -> , [1489:49]
16838 | | | | |--EXPR -> EXPR [1489:51]
16839 | | | | | `--STRING_LITERAL -> "static initialization rcurly" [1489:51]
16840 | | | | |--COMMA -> , [1489:81]
16841 | | | | |--EXPR -> EXPR [1489:83]
16842 | | | | | `--NUM_INT -> 2 [1489:83]
16843 | | | | |--COMMA -> , [1489:84]
16844 | | | | `--EXPR -> EXPR [1489:86]
16845 | | | | `--NUM_INT -> 4 [1489:86]
16846 | | | `--RPAREN -> ) [1489:87]
16847 | | |--COMMA -> , [1489:88]
16848 | | |--EXPR -> EXPR [1490:22]
16849 | | | `--PLUS -> + [1490:22]
16850 | | | |--STRING_LITERAL -> "107:3: " [1490:12]
16851 | | | `--METHOD_CALL -> ( [1490:39]
16852 | | | |--IDENT -> getCheckMessage [1490:24]
16853 | | | |--ELIST -> ELIST [1490:40]
16854 | | | | |--EXPR -> EXPR [1490:40]
16855 | | | | | `--IDENT -> MSG_ERROR [1490:40]
16856 | | | | |--COMMA -> , [1490:49]
16857 | | | | |--EXPR -> EXPR [1490:51]
16858 | | | | | `--STRING_LITERAL -> "static initialization" [1490:51]
16859 | | | | |--COMMA -> , [1490:74]
16860 | | | | |--EXPR -> EXPR [1490:76]
16861 | | | | | `--NUM_INT -> 2 [1490:76]
16862 | | | | |--COMMA -> , [1490:77]
16863 | | | | `--EXPR -> EXPR [1490:79]
16864 | | | | `--NUM_INT -> 4 [1490:79]
16865 | | | `--RPAREN -> ) [1490:80]
16866 | | |--COMMA -> , [1490:81]
16867 | | |--EXPR -> EXPR [1491:22]
16868 | | | `--PLUS -> + [1491:22]
16869 | | | |--STRING_LITERAL -> "109:7: " [1491:12]
16870 | | | `--METHOD_CALL -> ( [1491:39]
16871 | | | |--IDENT -> getCheckMessage [1491:24]
16872 | | | |--ELIST -> ELIST [1491:40]
16873 | | | | |--EXPR -> EXPR [1491:40]
16874 | | | | | `--IDENT -> MSG_ERROR [1491:40]
16875 | | | | |--COMMA -> , [1491:49]
16876 | | | | |--EXPR -> EXPR [1491:51]
16877 | | | | | `--STRING_LITERAL -> "static initialization rcurly" [1491:51]
16878 | | | | |--COMMA -> , [1491:81]
16879 | | | | |--EXPR -> EXPR [1491:83]
16880 | | | | | `--NUM_INT -> 6 [1491:83]
16881 | | | | |--COMMA -> , [1491:84]
16882 | | | | `--EXPR -> EXPR [1491:86]
16883 | | | | `--NUM_INT -> 4 [1491:86]
16884 | | | `--RPAREN -> ) [1491:87]
16885 | | |--COMMA -> , [1491:88]
16886 | | |--EXPR -> EXPR [1492:22]
16887 | | | `--PLUS -> + [1492:22]
16888 | | | |--STRING_LITERAL -> "111:3: " [1492:12]
16889 | | | `--METHOD_CALL -> ( [1492:39]
16890 | | | |--IDENT -> getCheckMessage [1492:24]
16891 | | | |--ELIST -> ELIST [1492:40]
16892 | | | | |--EXPR -> EXPR [1492:40]
16893 | | | | | `--IDENT -> MSG_ERROR [1492:40]
16894 | | | | |--COMMA -> , [1492:49]
16895 | | | | |--EXPR -> EXPR [1492:51]
16896 | | | | | `--STRING_LITERAL -> "static initialization" [1492:51]
16897 | | | | |--COMMA -> , [1492:74]
16898 | | | | |--EXPR -> EXPR [1492:76]
16899 | | | | | `--NUM_INT -> 2 [1492:76]
16900 | | | | |--COMMA -> , [1492:77]
16901 | | | | `--EXPR -> EXPR [1492:79]
16902 | | | | `--NUM_INT -> 4 [1492:79]
16903 | | | `--RPAREN -> ) [1492:80]
16904 | | |--COMMA -> , [1492:81]
16905 | | |--EXPR -> EXPR [1493:22]
16906 | | | `--PLUS -> + [1493:22]
16907 | | | |--STRING_LITERAL -> "113:7: " [1493:12]
16908 | | | `--METHOD_CALL -> ( [1493:39]
16909 | | | |--IDENT -> getCheckMessage [1493:24]
16910 | | | |--ELIST -> ELIST [1493:40]
16911 | | | | |--EXPR -> EXPR [1493:40]
16912 | | | | | `--IDENT -> MSG_CHILD_ERROR [1493:40]
16913 | | | | |--COMMA -> , [1493:55]
16914 | | | | |--EXPR -> EXPR [1493:57]
16915 | | | | | `--STRING_LITERAL -> "static initialization" [1493:57]
16916 | | | | |--COMMA -> , [1493:80]
16917 | | | | |--EXPR -> EXPR [1493:82]
16918 | | | | | `--NUM_INT -> 6 [1493:82]
16919 | | | | |--COMMA -> , [1493:83]
16920 | | | | `--EXPR -> EXPR [1493:85]
16921 | | | | `--NUM_INT -> 8 [1493:85]
16922 | | | `--RPAREN -> ) [1493:86]
16923 | | |--COMMA -> , [1493:87]
16924 | | |--EXPR -> EXPR [1494:22]
16925 | | | `--PLUS -> + [1494:22]
16926 | | | |--STRING_LITERAL -> "116:3: " [1494:12]
16927 | | | `--METHOD_CALL -> ( [1494:39]
16928 | | | |--IDENT -> getCheckMessage [1494:24]
16929 | | | |--ELIST -> ELIST [1494:40]
16930 | | | | |--EXPR -> EXPR [1494:40]
16931 | | | | | `--IDENT -> MSG_ERROR [1494:40]
16932 | | | | |--COMMA -> , [1494:49]
16933 | | | | |--EXPR -> EXPR [1494:51]
16934 | | | | | `--STRING_LITERAL -> "static initialization lcurly" [1494:51]
16935 | | | | |--COMMA -> , [1494:81]
16936 | | | | |--EXPR -> EXPR [1494:83]
16937 | | | | | `--NUM_INT -> 2 [1494:83]
16938 | | | | |--COMMA -> , [1494:84]
16939 | | | | `--EXPR -> EXPR [1494:86]
16940 | | | | `--NUM_INT -> 4 [1494:86]
16941 | | | `--RPAREN -> ) [1494:87]
16942 | | |--COMMA -> , [1494:88]
16943 | | |--EXPR -> EXPR [1495:22]
16944 | | | `--PLUS -> + [1495:22]
16945 | | | |--STRING_LITERAL -> "117:7: " [1495:12]
16946 | | | `--METHOD_CALL -> ( [1495:39]
16947 | | | |--IDENT -> getCheckMessage [1495:24]
16948 | | | |--ELIST -> ELIST [1495:40]
16949 | | | | |--EXPR -> EXPR [1495:40]
16950 | | | | | `--IDENT -> MSG_CHILD_ERROR [1495:40]
16951 | | | | |--COMMA -> , [1495:55]
16952 | | | | |--EXPR -> EXPR [1495:57]
16953 | | | | | `--STRING_LITERAL -> "static initialization" [1495:57]
16954 | | | | |--COMMA -> , [1495:80]
16955 | | | | |--EXPR -> EXPR [1495:82]
16956 | | | | | `--NUM_INT -> 6 [1495:82]
16957 | | | | |--COMMA -> , [1495:83]
16958 | | | | `--EXPR -> EXPR [1495:85]
16959 | | | | `--NUM_INT -> 8 [1495:85]
16960 | | | `--RPAREN -> ) [1495:86]
16961 | | |--COMMA -> , [1495:87]
16962 | | |--EXPR -> EXPR [1496:22]
16963 | | | `--PLUS -> + [1496:22]
16964 | | | |--STRING_LITERAL -> "118:7: " [1496:12]
16965 | | | `--METHOD_CALL -> ( [1496:39]
16966 | | | |--IDENT -> getCheckMessage [1496:24]
16967 | | | |--ELIST -> ELIST [1496:40]
16968 | | | | |--EXPR -> EXPR [1496:40]
16969 | | | | | `--IDENT -> MSG_ERROR [1496:40]
16970 | | | | |--COMMA -> , [1496:49]
16971 | | | | |--EXPR -> EXPR [1496:51]
16972 | | | | | `--STRING_LITERAL -> "static initialization rcurly" [1496:51]
16973 | | | | |--COMMA -> , [1496:81]
16974 | | | | |--EXPR -> EXPR [1496:83]
16975 | | | | | `--NUM_INT -> 6 [1496:83]
16976 | | | | |--COMMA -> , [1496:84]
16977 | | | | `--EXPR -> EXPR [1496:86]
16978 | | | | `--NUM_INT -> 4 [1496:86]
16979 | | | `--RPAREN -> ) [1496:87]
16980 | | |--COMMA -> , [1496:88]
16981 | | |--EXPR -> EXPR [1497:22]
16982 | | | `--PLUS -> + [1497:22]
16983 | | | |--STRING_LITERAL -> "123:7: " [1497:12]
16984 | | | `--METHOD_CALL -> ( [1497:39]
16985 | | | |--IDENT -> getCheckMessage [1497:24]
16986 | | | |--ELIST -> ELIST [1497:40]
16987 | | | | |--EXPR -> EXPR [1497:40]
16988 | | | | | `--IDENT -> MSG_CHILD_ERROR [1497:40]
16989 | | | | |--COMMA -> , [1497:55]
16990 | | | | |--EXPR -> EXPR [1497:57]
16991 | | | | | `--STRING_LITERAL -> "static initialization" [1497:57]
16992 | | | | |--COMMA -> , [1497:80]
16993 | | | | |--EXPR -> EXPR [1497:82]
16994 | | | | | `--NUM_INT -> 6 [1497:82]
16995 | | | | |--COMMA -> , [1497:83]
16996 | | | | `--EXPR -> EXPR [1497:85]
16997 | | | | `--NUM_INT -> 8 [1497:85]
16998 | | | `--RPAREN -> ) [1497:86]
16999 | | |--COMMA -> , [1497:87]
17000 | | |--EXPR -> EXPR [1498:22]
17001 | | | `--PLUS -> + [1498:22]
17002 | | | |--STRING_LITERAL -> "128:5: " [1498:12]
17003 | | | `--METHOD_CALL -> ( [1498:39]
17004 | | | |--IDENT -> getCheckMessage [1498:24]
17005 | | | |--ELIST -> ELIST [1498:40]
17006 | | | | |--EXPR -> EXPR [1498:40]
17007 | | | | | `--IDENT -> MSG_CHILD_ERROR [1498:40]
17008 | | | | |--COMMA -> , [1498:55]
17009 | | | | |--EXPR -> EXPR [1498:57]
17010 | | | | | `--STRING_LITERAL -> "static initialization" [1498:57]
17011 | | | | |--COMMA -> , [1498:80]
17012 | | | | |--EXPR -> EXPR [1498:82]
17013 | | | | | `--NUM_INT -> 4 [1498:82]
17014 | | | | |--COMMA -> , [1498:83]
17015 | | | | `--EXPR -> EXPR [1498:85]
17016 | | | | `--NUM_INT -> 8 [1498:85]
17017 | | | `--RPAREN -> ) [1498:86]
17018 | | |--COMMA -> , [1498:87]
17019 | | |--EXPR -> EXPR [1499:22]
17020 | | | `--PLUS -> + [1499:22]
17021 | | | |--STRING_LITERAL -> "129:3: " [1499:12]
17022 | | | `--METHOD_CALL -> ( [1499:39]
17023 | | | |--IDENT -> getCheckMessage [1499:24]
17024 | | | |--ELIST -> ELIST [1499:40]
17025 | | | | |--EXPR -> EXPR [1499:40]
17026 | | | | | `--IDENT -> MSG_ERROR [1499:40]
17027 | | | | |--COMMA -> , [1499:49]
17028 | | | | |--EXPR -> EXPR [1499:51]
17029 | | | | | `--STRING_LITERAL -> "static initialization rcurly" [1499:51]
17030 | | | | |--COMMA -> , [1499:81]
17031 | | | | |--EXPR -> EXPR [1499:83]
17032 | | | | | `--NUM_INT -> 2 [1499:83]
17033 | | | | |--COMMA -> , [1499:84]
17034 | | | | `--EXPR -> EXPR [1499:86]
17035 | | | | `--NUM_INT -> 4 [1499:86]
17036 | | | `--RPAREN -> ) [1499:87]
17037 | | |--COMMA -> , [1499:88]
17038 | | |--EXPR -> EXPR [1500:22]
17039 | | | `--PLUS -> + [1500:22]
17040 | | | |--STRING_LITERAL -> "134:7: " [1500:12]
17041 | | | `--METHOD_CALL -> ( [1500:39]
17042 | | | |--IDENT -> getCheckMessage [1500:24]
17043 | | | |--ELIST -> ELIST [1500:40]
17044 | | | | |--EXPR -> EXPR [1500:40]
17045 | | | | | `--IDENT -> MSG_ERROR [1500:40]
17046 | | | | |--COMMA -> , [1500:49]
17047 | | | | |--EXPR -> EXPR [1500:51]
17048 | | | | | `--STRING_LITERAL -> "static initialization rcurly" [1500:51]
17049 | | | | |--COMMA -> , [1500:81]
17050 | | | | |--EXPR -> EXPR [1500:83]
17051 | | | | | `--NUM_INT -> 6 [1500:83]
17052 | | | | |--COMMA -> , [1500:84]
17053 | | | | `--EXPR -> EXPR [1500:86]
17054 | | | | `--NUM_INT -> 4 [1500:86]
17055 | | | `--RPAREN -> ) [1500:87]
17056 | | |--COMMA -> , [1500:88]
17057 | | |--EXPR -> EXPR [1501:22]
17058 | | | `--PLUS -> + [1501:22]
17059 | | | |--STRING_LITERAL -> "137:3: " [1501:12]
17060 | | | `--METHOD_CALL -> ( [1501:39]
17061 | | | |--IDENT -> getCheckMessage [1501:24]
17062 | | | |--ELIST -> ELIST [1501:40]
17063 | | | | |--EXPR -> EXPR [1501:40]
17064 | | | | | `--IDENT -> MSG_ERROR [1501:40]
17065 | | | | |--COMMA -> , [1501:49]
17066 | | | | |--EXPR -> EXPR [1501:51]
17067 | | | | | `--STRING_LITERAL -> "block lcurly" [1501:51]
17068 | | | | |--COMMA -> , [1501:65]
17069 | | | | |--EXPR -> EXPR [1501:67]
17070 | | | | | `--NUM_INT -> 2 [1501:67]
17071 | | | | |--COMMA -> , [1501:68]
17072 | | | | `--EXPR -> EXPR [1501:70]
17073 | | | | `--NUM_INT -> 4 [1501:70]
17074 | | | `--RPAREN -> ) [1501:71]
17075 | | |--COMMA -> , [1501:72]
17076 | | |--EXPR -> EXPR [1502:22]
17077 | | | `--PLUS -> + [1502:22]
17078 | | | |--STRING_LITERAL -> "138:7: " [1502:12]
17079 | | | `--METHOD_CALL -> ( [1502:39]
17080 | | | |--IDENT -> getCheckMessage [1502:24]
17081 | | | |--ELIST -> ELIST [1502:40]
17082 | | | | |--EXPR -> EXPR [1502:40]
17083 | | | | | `--IDENT -> MSG_ERROR [1502:40]
17084 | | | | |--COMMA -> , [1502:49]
17085 | | | | |--EXPR -> EXPR [1502:51]
17086 | | | | | `--STRING_LITERAL -> "block lcurly" [1502:51]
17087 | | | | |--COMMA -> , [1502:65]
17088 | | | | |--EXPR -> EXPR [1502:67]
17089 | | | | | `--NUM_INT -> 6 [1502:67]
17090 | | | | |--COMMA -> , [1502:68]
17091 | | | | `--EXPR -> EXPR [1502:70]
17092 | | | | `--NUM_INT -> 4 [1502:70]
17093 | | | `--RPAREN -> ) [1502:71]
17094 | | |--COMMA -> , [1502:72]
17095 | | |--EXPR -> EXPR [1503:22]
17096 | | | `--PLUS -> + [1503:22]
17097 | | | |--STRING_LITERAL -> "141:3: " [1503:12]
17098 | | | `--METHOD_CALL -> ( [1503:39]
17099 | | | |--IDENT -> getCheckMessage [1503:24]
17100 | | | |--ELIST -> ELIST [1503:40]
17101 | | | | |--EXPR -> EXPR [1503:40]
17102 | | | | | `--IDENT -> MSG_ERROR [1503:40]
17103 | | | | |--COMMA -> , [1503:49]
17104 | | | | |--EXPR -> EXPR [1503:51]
17105 | | | | | `--STRING_LITERAL -> "block lcurly" [1503:51]
17106 | | | | |--COMMA -> , [1503:65]
17107 | | | | |--EXPR -> EXPR [1503:67]
17108 | | | | | `--NUM_INT -> 2 [1503:67]
17109 | | | | |--COMMA -> , [1503:68]
17110 | | | | `--EXPR -> EXPR [1503:70]
17111 | | | | `--NUM_INT -> 4 [1503:70]
17112 | | | `--RPAREN -> ) [1503:71]
17113 | | |--COMMA -> , [1503:72]
17114 | | |--EXPR -> EXPR [1504:22]
17115 | | | `--PLUS -> + [1504:22]
17116 | | | |--STRING_LITERAL -> "143:7: " [1504:12]
17117 | | | `--METHOD_CALL -> ( [1504:39]
17118 | | | |--IDENT -> getCheckMessage [1504:24]
17119 | | | |--ELIST -> ELIST [1504:40]
17120 | | | | |--EXPR -> EXPR [1504:40]
17121 | | | | | `--IDENT -> MSG_ERROR [1504:40]
17122 | | | | |--COMMA -> , [1504:49]
17123 | | | | |--EXPR -> EXPR [1504:51]
17124 | | | | | `--STRING_LITERAL -> "block rcurly" [1504:51]
17125 | | | | |--COMMA -> , [1504:65]
17126 | | | | |--EXPR -> EXPR [1504:67]
17127 | | | | | `--NUM_INT -> 6 [1504:67]
17128 | | | | |--COMMA -> , [1504:68]
17129 | | | | `--EXPR -> EXPR [1504:70]
17130 | | | | `--NUM_INT -> 4 [1504:70]
17131 | | | `--RPAREN -> ) [1504:71]
17132 | | |--COMMA -> , [1504:72]
17133 | | |--EXPR -> EXPR [1505:22]
17134 | | | `--PLUS -> + [1505:22]
17135 | | | |--STRING_LITERAL -> "145:7: " [1505:12]
17136 | | | `--METHOD_CALL -> ( [1505:39]
17137 | | | |--IDENT -> getCheckMessage [1505:24]
17138 | | | |--ELIST -> ELIST [1505:40]
17139 | | | | |--EXPR -> EXPR [1505:40]
17140 | | | | | `--IDENT -> MSG_ERROR [1505:40]
17141 | | | | |--COMMA -> , [1505:49]
17142 | | | | |--EXPR -> EXPR [1505:51]
17143 | | | | | `--STRING_LITERAL -> "block lcurly" [1505:51]
17144 | | | | |--COMMA -> , [1505:65]
17145 | | | | |--EXPR -> EXPR [1505:67]
17146 | | | | | `--NUM_INT -> 6 [1505:67]
17147 | | | | |--COMMA -> , [1505:68]
17148 | | | | `--EXPR -> EXPR [1505:70]
17149 | | | | `--NUM_INT -> 4 [1505:70]
17150 | | | `--RPAREN -> ) [1505:71]
17151 | | |--COMMA -> , [1505:72]
17152 | | |--EXPR -> EXPR [1506:22]
17153 | | | `--PLUS -> + [1506:22]
17154 | | | |--STRING_LITERAL -> "147:3: " [1506:12]
17155 | | | `--METHOD_CALL -> ( [1506:39]
17156 | | | |--IDENT -> getCheckMessage [1506:24]
17157 | | | |--ELIST -> ELIST [1506:40]
17158 | | | | |--EXPR -> EXPR [1506:40]
17159 | | | | | `--IDENT -> MSG_ERROR [1506:40]
17160 | | | | |--COMMA -> , [1506:49]
17161 | | | | |--EXPR -> EXPR [1506:51]
17162 | | | | | `--STRING_LITERAL -> "block rcurly" [1506:51]
17163 | | | | |--COMMA -> , [1506:65]
17164 | | | | |--EXPR -> EXPR [1506:67]
17165 | | | | | `--NUM_INT -> 2 [1506:67]
17166 | | | | |--COMMA -> , [1506:68]
17167 | | | | `--EXPR -> EXPR [1506:70]
17168 | | | | `--NUM_INT -> 4 [1506:70]
17169 | | | `--RPAREN -> ) [1506:71]
17170 | | |--COMMA -> , [1506:72]
17171 | | |--EXPR -> EXPR [1507:22]
17172 | | | `--PLUS -> + [1507:22]
17173 | | | |--STRING_LITERAL -> "150:7: " [1507:12]
17174 | | | `--METHOD_CALL -> ( [1507:39]
17175 | | | |--IDENT -> getCheckMessage [1507:24]
17176 | | | |--ELIST -> ELIST [1507:40]
17177 | | | | |--EXPR -> EXPR [1507:40]
17178 | | | | | `--IDENT -> MSG_CHILD_ERROR [1507:40]
17179 | | | | |--COMMA -> , [1507:55]
17180 | | | | |--EXPR -> EXPR [1507:57]
17181 | | | | | `--STRING_LITERAL -> "block" [1507:57]
17182 | | | | |--COMMA -> , [1507:64]
17183 | | | | |--EXPR -> EXPR [1507:66]
17184 | | | | | `--NUM_INT -> 6 [1507:66]
17185 | | | | |--COMMA -> , [1507:67]
17186 | | | | `--EXPR -> EXPR [1507:69]
17187 | | | | `--NUM_INT -> 8 [1507:69]
17188 | | | `--RPAREN -> ) [1507:70]
17189 | | |--COMMA -> , [1507:71]
17190 | | `--RCURLY -> } [1508:8]
17191 | |--SEMI -> ; [1508:9]
17192 | |--EXPR -> EXPR [1509:19]
17193 | | `--METHOD_CALL -> ( [1509:19]
17194 | | |--IDENT -> verifyWarns [1509:8]
17195 | | |--ELIST -> ELIST [1509:20]
17196 | | | |--EXPR -> EXPR [1509:20]
17197 | | | | `--IDENT -> checkConfig [1509:20]
17198 | | | |--COMMA -> , [1509:31]
17199 | | | |--EXPR -> EXPR [1509:33]
17200 | | | | `--IDENT -> fileName [1509:33]
17201 | | | |--COMMA -> , [1509:41]
17202 | | | `--EXPR -> EXPR [1509:43]
17203 | | | `--IDENT -> expected [1509:43]
17204 | | `--RPAREN -> ) [1509:51]
17205 | |--SEMI -> ; [1509:52]
17206 | `--RCURLY -> } [1510:4]
17207 |--METHOD_DEF -> METHOD_DEF [1512:4]
17208 | |--MODIFIERS -> MODIFIERS [1512:4]
17209 | | |--ANNOTATION -> ANNOTATION [1512:4]
17210 | | | |--AT -> @ [1512:4]
17211 | | | `--IDENT -> Test [1512:5]
17212 | | `--LITERAL_PUBLIC -> public [1513:4]
17213 | |--TYPE -> TYPE [1513:11]
17214 | | `--LITERAL_VOID -> void [1513:11]
17215 | |--IDENT -> testInvalidIfWithChecker [1513:16]
17216 | |--LPAREN -> ( [1513:40]
17217 | |--PARAMETERS -> PARAMETERS [1513:41]
17218 | |--RPAREN -> ) [1513:41]
17219 | |--LITERAL_THROWS -> throws [1514:12]
17220 | | `--IDENT -> Exception [1514:19]
17221 | `--SLIST -> { [1514:29]
17222 | |--VARIABLE_DEF -> VARIABLE_DEF [1515:8]
17223 | | |--MODIFIERS -> MODIFIERS [1515:8]
17224 | | | `--FINAL -> final [1515:8]
17225 | | |--TYPE -> TYPE [1515:14]
17226 | | | `--IDENT -> DefaultConfiguration [1515:14]
17227 | | |--IDENT -> checkConfig [1515:35]
17228 | | `--ASSIGN -> = [1515:47]
17229 | | `--EXPR -> EXPR [1515:67]
17230 | | `--METHOD_CALL -> ( [1515:67]
17231 | | |--IDENT -> createModuleConfig [1515:49]
17232 | | |--ELIST -> ELIST [1515:84]
17233 | | | `--EXPR -> EXPR [1515:84]
17234 | | | `--DOT -> . [1515:84]
17235 | | | |--IDENT -> IndentationCheck [1515:68]
17236 | | | `--LITERAL_CLASS -> class [1515:85]
17237 | | `--RPAREN -> ) [1515:90]
17238 | |--SEMI -> ; [1515:91]
17239 | |--EXPR -> EXPR [1517:32]
17240 | | `--METHOD_CALL -> ( [1517:32]
17241 | | |--DOT -> . [1517:19]
17242 | | | |--IDENT -> checkConfig [1517:8]
17243 | | | `--IDENT -> addAttribute [1517:20]
17244 | | |--ELIST -> ELIST [1517:33]
17245 | | | |--EXPR -> EXPR [1517:33]
17246 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1517:33]
17247 | | | |--COMMA -> , [1517:50]
17248 | | | `--EXPR -> EXPR [1517:52]
17249 | | | `--STRING_LITERAL -> "4" [1517:52]
17250 | | `--RPAREN -> ) [1517:55]
17251 | |--SEMI -> ; [1517:56]
17252 | |--EXPR -> EXPR [1518:32]
17253 | | `--METHOD_CALL -> ( [1518:32]
17254 | | |--DOT -> . [1518:19]
17255 | | | |--IDENT -> checkConfig [1518:8]
17256 | | | `--IDENT -> addAttribute [1518:20]
17257 | | |--ELIST -> ELIST [1518:33]
17258 | | | |--EXPR -> EXPR [1518:33]
17259 | | | | `--STRING_LITERAL -> "basicOffset" [1518:33]
17260 | | | |--COMMA -> , [1518:46]
17261 | | | `--EXPR -> EXPR [1518:48]
17262 | | | `--STRING_LITERAL -> "4" [1518:48]
17263 | | `--RPAREN -> ) [1518:51]
17264 | |--SEMI -> ; [1518:52]
17265 | |--EXPR -> EXPR [1519:32]
17266 | | `--METHOD_CALL -> ( [1519:32]
17267 | | |--DOT -> . [1519:19]
17268 | | | |--IDENT -> checkConfig [1519:8]
17269 | | | `--IDENT -> addAttribute [1519:20]
17270 | | |--ELIST -> ELIST [1519:33]
17271 | | | |--EXPR -> EXPR [1519:33]
17272 | | | | `--STRING_LITERAL -> "braceAdjustment" [1519:33]
17273 | | | |--COMMA -> , [1519:50]
17274 | | | `--EXPR -> EXPR [1519:52]
17275 | | | `--STRING_LITERAL -> "0" [1519:52]
17276 | | `--RPAREN -> ) [1519:55]
17277 | |--SEMI -> ; [1519:56]
17278 | |--EXPR -> EXPR [1520:32]
17279 | | `--METHOD_CALL -> ( [1520:32]
17280 | | |--DOT -> . [1520:19]
17281 | | | |--IDENT -> checkConfig [1520:8]
17282 | | | `--IDENT -> addAttribute [1520:20]
17283 | | |--ELIST -> ELIST [1520:33]
17284 | | | |--EXPR -> EXPR [1520:33]
17285 | | | | `--STRING_LITERAL -> "caseIndent" [1520:33]
17286 | | | |--COMMA -> , [1520:45]
17287 | | | `--EXPR -> EXPR [1520:47]
17288 | | | `--STRING_LITERAL -> "4" [1520:47]
17289 | | `--RPAREN -> ) [1520:50]
17290 | |--SEMI -> ; [1520:51]
17291 | |--EXPR -> EXPR [1521:32]
17292 | | `--METHOD_CALL -> ( [1521:32]
17293 | | |--DOT -> . [1521:19]
17294 | | | |--IDENT -> checkConfig [1521:8]
17295 | | | `--IDENT -> addAttribute [1521:20]
17296 | | |--ELIST -> ELIST [1521:33]
17297 | | | |--EXPR -> EXPR [1521:33]
17298 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1521:33]
17299 | | | |--COMMA -> , [1521:55]
17300 | | | `--EXPR -> EXPR [1521:57]
17301 | | | `--STRING_LITERAL -> "false" [1521:57]
17302 | | `--RPAREN -> ) [1521:64]
17303 | |--SEMI -> ; [1521:65]
17304 | |--EXPR -> EXPR [1522:32]
17305 | | `--METHOD_CALL -> ( [1522:32]
17306 | | |--DOT -> . [1522:19]
17307 | | | |--IDENT -> checkConfig [1522:8]
17308 | | | `--IDENT -> addAttribute [1522:20]
17309 | | |--ELIST -> ELIST [1522:33]
17310 | | | |--EXPR -> EXPR [1522:33]
17311 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1522:33]
17312 | | | |--COMMA -> , [1522:58]
17313 | | | `--EXPR -> EXPR [1522:60]
17314 | | | `--STRING_LITERAL -> "4" [1522:60]
17315 | | `--RPAREN -> ) [1522:63]
17316 | |--SEMI -> ; [1522:64]
17317 | |--EXPR -> EXPR [1523:32]
17318 | | `--METHOD_CALL -> ( [1523:32]
17319 | | |--DOT -> . [1523:19]
17320 | | | |--IDENT -> checkConfig [1523:8]
17321 | | | `--IDENT -> addAttribute [1523:20]
17322 | | |--ELIST -> ELIST [1523:33]
17323 | | | |--EXPR -> EXPR [1523:33]
17324 | | | | `--STRING_LITERAL -> "tabWidth" [1523:33]
17325 | | | |--COMMA -> , [1523:43]
17326 | | | `--EXPR -> EXPR [1523:45]
17327 | | | `--STRING_LITERAL -> "4" [1523:45]
17328 | | `--RPAREN -> ) [1523:48]
17329 | |--SEMI -> ; [1523:49]
17330 | |--EXPR -> EXPR [1524:32]
17331 | | `--METHOD_CALL -> ( [1524:32]
17332 | | |--DOT -> . [1524:19]
17333 | | | |--IDENT -> checkConfig [1524:8]
17334 | | | `--IDENT -> addAttribute [1524:20]
17335 | | |--ELIST -> ELIST [1524:33]
17336 | | | |--EXPR -> EXPR [1524:33]
17337 | | | | `--STRING_LITERAL -> "throwsIndent" [1524:33]
17338 | | | |--COMMA -> , [1524:47]
17339 | | | `--EXPR -> EXPR [1524:49]
17340 | | | `--STRING_LITERAL -> "4" [1524:49]
17341 | | `--RPAREN -> ) [1524:52]
17342 | |--SEMI -> ; [1524:53]
17343 | |--VARIABLE_DEF -> VARIABLE_DEF [1525:8]
17344 | | |--MODIFIERS -> MODIFIERS [1525:8]
17345 | | | `--FINAL -> final [1525:8]
17346 | | |--TYPE -> TYPE [1525:14]
17347 | | | `--IDENT -> String [1525:14]
17348 | | |--IDENT -> fileName [1525:21]
17349 | | `--ASSIGN -> = [1525:30]
17350 | | `--EXPR -> EXPR [1525:39]
17351 | | `--METHOD_CALL -> ( [1525:39]
17352 | | |--IDENT -> getPath [1525:32]
17353 | | |--ELIST -> ELIST [1525:40]
17354 | | | `--EXPR -> EXPR [1525:40]
17355 | | | `--STRING_LITERAL -> "InputIndentationInvalidIfIndent.java" [1525:40]
17356 | | `--RPAREN -> ) [1525:78]
17357 | |--SEMI -> ; [1525:79]
17358 | |--VARIABLE_DEF -> VARIABLE_DEF [1526:8]
17359 | | |--MODIFIERS -> MODIFIERS [1526:8]
17360 | | | `--FINAL -> final [1526:8]
17361 | | |--TYPE -> TYPE [1526:20]
17362 | | | `--ARRAY_DECLARATOR -> [ [1526:20]
17363 | | | |--IDENT -> String [1526:14]
17364 | | | `--RBRACK -> ] [1526:21]
17365 | | |--IDENT -> expected [1526:23]
17366 | | `--ASSIGN -> = [1526:32]
17367 | | `--ARRAY_INIT -> { [1526:34]
17368 | | |--EXPR -> EXPR [1527:21]
17369 | | | `--PLUS -> + [1527:21]
17370 | | | |--STRING_LITERAL -> "55:2: " [1527:12]
17371 | | | `--METHOD_CALL -> ( [1527:38]
17372 | | | |--IDENT -> getCheckMessage [1527:23]
17373 | | | |--ELIST -> ELIST [1527:39]
17374 | | | | |--EXPR -> EXPR [1527:39]
17375 | | | | | `--IDENT -> MSG_ERROR [1527:39]
17376 | | | | |--COMMA -> , [1527:48]
17377 | | | | |--EXPR -> EXPR [1527:50]
17378 | | | | | `--STRING_LITERAL -> "if" [1527:50]
17379 | | | | |--COMMA -> , [1527:54]
17380 | | | | |--EXPR -> EXPR [1527:56]
17381 | | | | | `--NUM_INT -> 1 [1527:56]
17382 | | | | |--COMMA -> , [1527:57]
17383 | | | | `--EXPR -> EXPR [1527:59]
17384 | | | | `--NUM_INT -> 8 [1527:59]
17385 | | | `--RPAREN -> ) [1527:60]
17386 | | |--COMMA -> , [1527:61]
17387 | | |--EXPR -> EXPR [1528:22]
17388 | | | `--PLUS -> + [1528:22]
17389 | | | |--STRING_LITERAL -> "60:10: " [1528:12]
17390 | | | `--METHOD_CALL -> ( [1528:39]
17391 | | | |--IDENT -> getCheckMessage [1528:24]
17392 | | | |--ELIST -> ELIST [1528:40]
17393 | | | | |--EXPR -> EXPR [1528:40]
17394 | | | | | `--IDENT -> MSG_ERROR [1528:40]
17395 | | | | |--COMMA -> , [1528:49]
17396 | | | | |--EXPR -> EXPR [1528:51]
17397 | | | | | `--STRING_LITERAL -> "if" [1528:51]
17398 | | | | |--COMMA -> , [1528:55]
17399 | | | | |--EXPR -> EXPR [1528:57]
17400 | | | | | `--NUM_INT -> 9 [1528:57]
17401 | | | | |--COMMA -> , [1528:58]
17402 | | | | `--EXPR -> EXPR [1528:60]
17403 | | | | `--NUM_INT -> 8 [1528:60]
17404 | | | `--RPAREN -> ) [1528:61]
17405 | | |--COMMA -> , [1528:62]
17406 | | |--EXPR -> EXPR [1529:22]
17407 | | | `--PLUS -> + [1529:22]
17408 | | | |--STRING_LITERAL -> "61:10: " [1529:12]
17409 | | | `--METHOD_CALL -> ( [1529:39]
17410 | | | |--IDENT -> getCheckMessage [1529:24]
17411 | | | |--ELIST -> ELIST [1529:40]
17412 | | | | |--EXPR -> EXPR [1529:40]
17413 | | | | | `--IDENT -> MSG_ERROR [1529:40]
17414 | | | | |--COMMA -> , [1529:49]
17415 | | | | |--EXPR -> EXPR [1529:51]
17416 | | | | | `--STRING_LITERAL -> "if lcurly" [1529:51]
17417 | | | | |--COMMA -> , [1529:62]
17418 | | | | |--EXPR -> EXPR [1529:64]
17419 | | | | | `--NUM_INT -> 9 [1529:64]
17420 | | | | |--COMMA -> , [1529:65]
17421 | | | | `--EXPR -> EXPR [1529:67]
17422 | | | | `--NUM_INT -> 8 [1529:67]
17423 | | | `--RPAREN -> ) [1529:68]
17424 | | |--COMMA -> , [1529:69]
17425 | | |--EXPR -> EXPR [1530:21]
17426 | | | `--PLUS -> + [1530:21]
17427 | | | |--STRING_LITERAL -> "62:8: " [1530:12]
17428 | | | `--METHOD_CALL -> ( [1530:38]
17429 | | | |--IDENT -> getCheckMessage [1530:23]
17430 | | | |--ELIST -> ELIST [1530:39]
17431 | | | | |--EXPR -> EXPR [1530:39]
17432 | | | | | `--IDENT -> MSG_ERROR [1530:39]
17433 | | | | |--COMMA -> , [1530:48]
17434 | | | | |--EXPR -> EXPR [1530:50]
17435 | | | | | `--STRING_LITERAL -> "if rcurly" [1530:50]
17436 | | | | |--COMMA -> , [1530:61]
17437 | | | | |--EXPR -> EXPR [1530:63]
17438 | | | | | `--NUM_INT -> 7 [1530:63]
17439 | | | | |--COMMA -> , [1530:64]
17440 | | | | `--EXPR -> EXPR [1530:66]
17441 | | | | `--NUM_INT -> 8 [1530:66]
17442 | | | `--RPAREN -> ) [1530:67]
17443 | | |--COMMA -> , [1530:68]
17444 | | |--EXPR -> EXPR [1531:21]
17445 | | | `--PLUS -> + [1531:21]
17446 | | | |--STRING_LITERAL -> "64:7: " [1531:12]
17447 | | | `--METHOD_CALL -> ( [1531:38]
17448 | | | |--IDENT -> getCheckMessage [1531:23]
17449 | | | |--ELIST -> ELIST [1531:39]
17450 | | | | |--EXPR -> EXPR [1531:39]
17451 | | | | | `--IDENT -> MSG_ERROR [1531:39]
17452 | | | | |--COMMA -> , [1531:48]
17453 | | | | |--EXPR -> EXPR [1531:50]
17454 | | | | | `--STRING_LITERAL -> "if" [1531:50]
17455 | | | | |--COMMA -> , [1531:54]
17456 | | | | |--EXPR -> EXPR [1531:56]
17457 | | | | | `--NUM_INT -> 6 [1531:56]
17458 | | | | |--COMMA -> , [1531:57]
17459 | | | | `--EXPR -> EXPR [1531:59]
17460 | | | | `--NUM_INT -> 8 [1531:59]
17461 | | | `--RPAREN -> ) [1531:60]
17462 | | |--COMMA -> , [1531:61]
17463 | | |--EXPR -> EXPR [1532:21]
17464 | | | `--PLUS -> + [1532:21]
17465 | | | |--STRING_LITERAL -> "65:6: " [1532:12]
17466 | | | `--METHOD_CALL -> ( [1532:38]
17467 | | | |--IDENT -> getCheckMessage [1532:23]
17468 | | | |--ELIST -> ELIST [1532:39]
17469 | | | | |--EXPR -> EXPR [1532:39]
17470 | | | | | `--IDENT -> MSG_ERROR [1532:39]
17471 | | | | |--COMMA -> , [1532:48]
17472 | | | | |--EXPR -> EXPR [1532:50]
17473 | | | | | `--STRING_LITERAL -> "if lcurly" [1532:50]
17474 | | | | |--COMMA -> , [1532:61]
17475 | | | | |--EXPR -> EXPR [1532:63]
17476 | | | | | `--NUM_INT -> 5 [1532:63]
17477 | | | | |--COMMA -> , [1532:64]
17478 | | | | `--EXPR -> EXPR [1532:66]
17479 | | | | `--NUM_INT -> 8 [1532:66]
17480 | | | `--RPAREN -> ) [1532:67]
17481 | | |--COMMA -> , [1532:68]
17482 | | |--EXPR -> EXPR [1533:21]
17483 | | | `--PLUS -> + [1533:21]
17484 | | | |--STRING_LITERAL -> "66:6: " [1533:12]
17485 | | | `--METHOD_CALL -> ( [1533:38]
17486 | | | |--IDENT -> getCheckMessage [1533:23]
17487 | | | |--ELIST -> ELIST [1533:39]
17488 | | | | |--EXPR -> EXPR [1533:39]
17489 | | | | | `--IDENT -> MSG_ERROR [1533:39]
17490 | | | | |--COMMA -> , [1533:48]
17491 | | | | |--EXPR -> EXPR [1533:50]
17492 | | | | | `--STRING_LITERAL -> "if rcurly" [1533:50]
17493 | | | | |--COMMA -> , [1533:61]
17494 | | | | |--EXPR -> EXPR [1533:63]
17495 | | | | | `--NUM_INT -> 5 [1533:63]
17496 | | | | |--COMMA -> , [1533:64]
17497 | | | | `--EXPR -> EXPR [1533:66]
17498 | | | | `--NUM_INT -> 8 [1533:66]
17499 | | | `--RPAREN -> ) [1533:67]
17500 | | |--COMMA -> , [1533:68]
17501 | | |--EXPR -> EXPR [1534:22]
17502 | | | `--PLUS -> + [1534:22]
17503 | | | |--STRING_LITERAL -> "70:11: " [1534:12]
17504 | | | `--METHOD_CALL -> ( [1534:39]
17505 | | | |--IDENT -> getCheckMessage [1534:24]
17506 | | | |--ELIST -> ELIST [1534:40]
17507 | | | | |--EXPR -> EXPR [1534:40]
17508 | | | | | `--IDENT -> MSG_ERROR [1534:40]
17509 | | | | |--COMMA -> , [1534:49]
17510 | | | | |--EXPR -> EXPR [1534:51]
17511 | | | | | `--STRING_LITERAL -> "if rcurly" [1534:51]
17512 | | | | |--COMMA -> , [1534:62]
17513 | | | | |--EXPR -> EXPR [1534:64]
17514 | | | | | `--NUM_INT -> 10 [1534:64]
17515 | | | | |--COMMA -> , [1534:66]
17516 | | | | `--EXPR -> EXPR [1534:68]
17517 | | | | `--NUM_INT -> 8 [1534:68]
17518 | | | `--RPAREN -> ) [1534:69]
17519 | | |--COMMA -> , [1534:70]
17520 | | |--EXPR -> EXPR [1535:21]
17521 | | | `--PLUS -> + [1535:21]
17522 | | | |--STRING_LITERAL -> "71:8: " [1535:12]
17523 | | | `--METHOD_CALL -> ( [1535:38]
17524 | | | |--IDENT -> getCheckMessage [1535:23]
17525 | | | |--ELIST -> ELIST [1535:39]
17526 | | | | |--EXPR -> EXPR [1535:39]
17527 | | | | | `--IDENT -> MSG_ERROR [1535:39]
17528 | | | | |--COMMA -> , [1535:48]
17529 | | | | |--EXPR -> EXPR [1535:50]
17530 | | | | | `--STRING_LITERAL -> "else rcurly" [1535:50]
17531 | | | | |--COMMA -> , [1535:63]
17532 | | | | |--EXPR -> EXPR [1535:65]
17533 | | | | | `--NUM_INT -> 7 [1535:65]
17534 | | | | |--COMMA -> , [1535:66]
17535 | | | | `--EXPR -> EXPR [1535:68]
17536 | | | | `--NUM_INT -> 8 [1535:68]
17537 | | | `--RPAREN -> ) [1535:69]
17538 | | |--COMMA -> , [1535:70]
17539 | | |--EXPR -> EXPR [1536:22]
17540 | | | `--PLUS -> + [1536:22]
17541 | | | |--STRING_LITERAL -> "74:10: " [1536:12]
17542 | | | `--METHOD_CALL -> ( [1536:39]
17543 | | | |--IDENT -> getCheckMessage [1536:24]
17544 | | | |--ELIST -> ELIST [1536:40]
17545 | | | | |--EXPR -> EXPR [1536:40]
17546 | | | | | `--IDENT -> MSG_ERROR [1536:40]
17547 | | | | |--COMMA -> , [1536:49]
17548 | | | | |--EXPR -> EXPR [1536:51]
17549 | | | | | `--STRING_LITERAL -> "if" [1536:51]
17550 | | | | |--COMMA -> , [1536:55]
17551 | | | | |--EXPR -> EXPR [1536:57]
17552 | | | | | `--NUM_INT -> 9 [1536:57]
17553 | | | | |--COMMA -> , [1536:58]
17554 | | | | `--EXPR -> EXPR [1536:60]
17555 | | | | `--NUM_INT -> 8 [1536:60]
17556 | | | `--RPAREN -> ) [1536:61]
17557 | | |--COMMA -> , [1536:62]
17558 | | |--EXPR -> EXPR [1538:21]
17559 | | | `--PLUS -> + [1538:21]
17560 | | | |--STRING_LITERAL -> "75:8: " [1538:12]
17561 | | | `--METHOD_CALL -> ( [1538:38]
17562 | | | |--IDENT -> getCheckMessage [1538:23]
17563 | | | |--ELIST -> ELIST [1538:39]
17564 | | | | |--EXPR -> EXPR [1538:39]
17565 | | | | | `--IDENT -> MSG_ERROR [1538:39]
17566 | | | | |--COMMA -> , [1538:48]
17567 | | | | |--EXPR -> EXPR [1538:50]
17568 | | | | | `--STRING_LITERAL -> "if lcurly" [1538:50]
17569 | | | | |--COMMA -> , [1538:61]
17570 | | | | |--EXPR -> EXPR [1538:63]
17571 | | | | | `--NUM_INT -> 7 [1538:63]
17572 | | | | |--COMMA -> , [1538:64]
17573 | | | | `--EXPR -> EXPR [1538:66]
17574 | | | | `--NUM_INT -> 8 [1538:66]
17575 | | | `--RPAREN -> ) [1538:67]
17576 | | |--COMMA -> , [1538:68]
17577 | | |--EXPR -> EXPR [1539:22]
17578 | | | `--PLUS -> + [1539:22]
17579 | | | |--STRING_LITERAL -> "77:10: " [1539:12]
17580 | | | `--METHOD_CALL -> ( [1539:39]
17581 | | | |--IDENT -> getCheckMessage [1539:24]
17582 | | | |--ELIST -> ELIST [1539:40]
17583 | | | | |--EXPR -> EXPR [1539:40]
17584 | | | | | `--IDENT -> MSG_ERROR [1539:40]
17585 | | | | |--COMMA -> , [1539:49]
17586 | | | | |--EXPR -> EXPR [1539:51]
17587 | | | | | `--STRING_LITERAL -> "else" [1539:51]
17588 | | | | |--COMMA -> , [1539:57]
17589 | | | | |--EXPR -> EXPR [1539:59]
17590 | | | | | `--NUM_INT -> 9 [1539:59]
17591 | | | | |--COMMA -> , [1539:60]
17592 | | | | `--EXPR -> EXPR [1539:62]
17593 | | | | `--NUM_INT -> 8 [1539:62]
17594 | | | `--RPAREN -> ) [1539:63]
17595 | | |--COMMA -> , [1539:64]
17596 | | |--EXPR -> EXPR [1540:22]
17597 | | | `--PLUS -> + [1540:22]
17598 | | | |--STRING_LITERAL -> "79:10: " [1540:12]
17599 | | | `--METHOD_CALL -> ( [1540:39]
17600 | | | |--IDENT -> getCheckMessage [1540:24]
17601 | | | |--ELIST -> ELIST [1540:40]
17602 | | | | |--EXPR -> EXPR [1540:40]
17603 | | | | | `--IDENT -> MSG_ERROR [1540:40]
17604 | | | | |--COMMA -> , [1540:49]
17605 | | | | |--EXPR -> EXPR [1540:51]
17606 | | | | | `--STRING_LITERAL -> "else rcurly" [1540:51]
17607 | | | | |--COMMA -> , [1540:64]
17608 | | | | |--EXPR -> EXPR [1540:66]
17609 | | | | | `--NUM_INT -> 9 [1540:66]
17610 | | | | |--COMMA -> , [1540:67]
17611 | | | | `--EXPR -> EXPR [1540:69]
17612 | | | | `--NUM_INT -> 8 [1540:69]
17613 | | | `--RPAREN -> ) [1540:70]
17614 | | |--COMMA -> , [1540:71]
17615 | | |--EXPR -> EXPR [1541:22]
17616 | | | `--PLUS -> + [1541:22]
17617 | | | |--STRING_LITERAL -> "82:11: " [1541:12]
17618 | | | `--METHOD_CALL -> ( [1541:39]
17619 | | | |--IDENT -> getCheckMessage [1541:24]
17620 | | | |--ELIST -> ELIST [1541:40]
17621 | | | | |--EXPR -> EXPR [1541:40]
17622 | | | | | `--IDENT -> MSG_ERROR [1541:40]
17623 | | | | |--COMMA -> , [1541:49]
17624 | | | | |--EXPR -> EXPR [1541:51]
17625 | | | | | `--STRING_LITERAL -> "if" [1541:51]
17626 | | | | |--COMMA -> , [1541:55]
17627 | | | | |--EXPR -> EXPR [1541:57]
17628 | | | | | `--NUM_INT -> 10 [1541:57]
17629 | | | | |--COMMA -> , [1541:59]
17630 | | | | `--EXPR -> EXPR [1541:61]
17631 | | | | `--NUM_INT -> 8 [1541:61]
17632 | | | `--RPAREN -> ) [1541:62]
17633 | | |--COMMA -> , [1541:63]
17634 | | |--EXPR -> EXPR [1542:21]
17635 | | | `--PLUS -> + [1542:21]
17636 | | | |--STRING_LITERAL -> "83:8: " [1542:12]
17637 | | | `--METHOD_CALL -> ( [1542:38]
17638 | | | |--IDENT -> getCheckMessage [1542:23]
17639 | | | |--ELIST -> ELIST [1542:39]
17640 | | | | |--EXPR -> EXPR [1542:39]
17641 | | | | | `--IDENT -> MSG_ERROR [1542:39]
17642 | | | | |--COMMA -> , [1542:48]
17643 | | | | |--EXPR -> EXPR [1542:50]
17644 | | | | | `--STRING_LITERAL -> "if rcurly" [1542:50]
17645 | | | | |--COMMA -> , [1542:61]
17646 | | | | |--EXPR -> EXPR [1542:63]
17647 | | | | | `--NUM_INT -> 7 [1542:63]
17648 | | | | |--COMMA -> , [1542:64]
17649 | | | | `--EXPR -> EXPR [1542:66]
17650 | | | | `--NUM_INT -> 8 [1542:66]
17651 | | | `--RPAREN -> ) [1542:67]
17652 | | |--COMMA -> , [1542:68]
17653 | | |--EXPR -> EXPR [1543:22]
17654 | | | `--PLUS -> + [1543:22]
17655 | | | |--STRING_LITERAL -> "84:10: " [1543:12]
17656 | | | `--METHOD_CALL -> ( [1543:39]
17657 | | | |--IDENT -> getCheckMessage [1543:24]
17658 | | | |--ELIST -> ELIST [1543:40]
17659 | | | | |--EXPR -> EXPR [1543:40]
17660 | | | | | `--IDENT -> MSG_ERROR [1543:40]
17661 | | | | |--COMMA -> , [1543:49]
17662 | | | | |--EXPR -> EXPR [1543:51]
17663 | | | | | `--STRING_LITERAL -> "else" [1543:51]
17664 | | | | |--COMMA -> , [1543:57]
17665 | | | | |--EXPR -> EXPR [1543:59]
17666 | | | | | `--NUM_INT -> 9 [1543:59]
17667 | | | | |--COMMA -> , [1543:60]
17668 | | | | `--EXPR -> EXPR [1543:62]
17669 | | | | `--NUM_INT -> 8 [1543:62]
17670 | | | `--RPAREN -> ) [1543:63]
17671 | | |--COMMA -> , [1543:64]
17672 | | |--EXPR -> EXPR [1544:21]
17673 | | | `--PLUS -> + [1544:21]
17674 | | | |--STRING_LITERAL -> "85:8: " [1544:12]
17675 | | | `--METHOD_CALL -> ( [1544:38]
17676 | | | |--IDENT -> getCheckMessage [1544:23]
17677 | | | |--ELIST -> ELIST [1544:39]
17678 | | | | |--EXPR -> EXPR [1544:39]
17679 | | | | | `--IDENT -> MSG_ERROR [1544:39]
17680 | | | | |--COMMA -> , [1544:48]
17681 | | | | |--EXPR -> EXPR [1544:50]
17682 | | | | | `--STRING_LITERAL -> "else lcurly" [1544:50]
17683 | | | | |--COMMA -> , [1544:63]
17684 | | | | |--EXPR -> EXPR [1544:65]
17685 | | | | | `--NUM_INT -> 7 [1544:65]
17686 | | | | |--COMMA -> , [1544:66]
17687 | | | | `--EXPR -> EXPR [1544:68]
17688 | | | | `--NUM_INT -> 8 [1544:68]
17689 | | | `--RPAREN -> ) [1544:69]
17690 | | |--COMMA -> , [1544:70]
17691 | | |--EXPR -> EXPR [1545:22]
17692 | | | `--PLUS -> + [1545:22]
17693 | | | |--STRING_LITERAL -> "86:10: " [1545:12]
17694 | | | `--METHOD_CALL -> ( [1545:39]
17695 | | | |--IDENT -> getCheckMessage [1545:24]
17696 | | | |--ELIST -> ELIST [1545:40]
17697 | | | | |--EXPR -> EXPR [1545:40]
17698 | | | | | `--IDENT -> MSG_ERROR [1545:40]
17699 | | | | |--COMMA -> , [1545:49]
17700 | | | | |--EXPR -> EXPR [1545:51]
17701 | | | | | `--STRING_LITERAL -> "else rcurly" [1545:51]
17702 | | | | |--COMMA -> , [1545:64]
17703 | | | | |--EXPR -> EXPR [1545:66]
17704 | | | | | `--NUM_INT -> 9 [1545:66]
17705 | | | | |--COMMA -> , [1545:67]
17706 | | | | `--EXPR -> EXPR [1545:69]
17707 | | | | `--NUM_INT -> 8 [1545:69]
17708 | | | `--RPAREN -> ) [1545:70]
17709 | | |--COMMA -> , [1545:71]
17710 | | |--EXPR -> EXPR [1547:22]
17711 | | | `--PLUS -> + [1547:22]
17712 | | | |--STRING_LITERAL -> "90:10: " [1547:12]
17713 | | | `--METHOD_CALL -> ( [1547:39]
17714 | | | |--IDENT -> getCheckMessage [1547:24]
17715 | | | |--ELIST -> ELIST [1547:40]
17716 | | | | |--EXPR -> EXPR [1547:40]
17717 | | | | | `--IDENT -> MSG_ERROR [1547:40]
17718 | | | | |--COMMA -> , [1547:49]
17719 | | | | |--EXPR -> EXPR [1547:51]
17720 | | | | | `--STRING_LITERAL -> "if" [1547:51]
17721 | | | | |--COMMA -> , [1547:55]
17722 | | | | |--EXPR -> EXPR [1547:57]
17723 | | | | | `--NUM_INT -> 9 [1547:57]
17724 | | | | |--COMMA -> , [1547:58]
17725 | | | | `--EXPR -> EXPR [1547:60]
17726 | | | | `--NUM_INT -> 8 [1547:60]
17727 | | | `--RPAREN -> ) [1547:61]
17728 | | |--COMMA -> , [1547:62]
17729 | | |--EXPR -> EXPR [1548:22]
17730 | | | `--PLUS -> + [1548:22]
17731 | | | |--STRING_LITERAL -> "91:10: " [1548:12]
17732 | | | `--METHOD_CALL -> ( [1548:39]
17733 | | | |--IDENT -> getCheckMessage [1548:24]
17734 | | | |--ELIST -> ELIST [1548:40]
17735 | | | | |--EXPR -> EXPR [1548:40]
17736 | | | | | `--IDENT -> MSG_ERROR [1548:40]
17737 | | | | |--COMMA -> , [1548:49]
17738 | | | | |--EXPR -> EXPR [1548:51]
17739 | | | | | `--STRING_LITERAL -> "if lcurly" [1548:51]
17740 | | | | |--COMMA -> , [1548:62]
17741 | | | | |--EXPR -> EXPR [1548:64]
17742 | | | | | `--NUM_INT -> 9 [1548:64]
17743 | | | | |--COMMA -> , [1548:65]
17744 | | | | `--EXPR -> EXPR [1548:67]
17745 | | | | `--NUM_INT -> 8 [1548:67]
17746 | | | `--RPAREN -> ) [1548:68]
17747 | | |--COMMA -> , [1548:69]
17748 | | |--EXPR -> EXPR [1549:22]
17749 | | | `--PLUS -> + [1549:22]
17750 | | | |--STRING_LITERAL -> "92:10: " [1549:12]
17751 | | | `--METHOD_CALL -> ( [1549:39]
17752 | | | |--IDENT -> getCheckMessage [1549:24]
17753 | | | |--ELIST -> ELIST [1549:40]
17754 | | | | |--EXPR -> EXPR [1549:40]
17755 | | | | | `--IDENT -> MSG_ERROR [1549:40]
17756 | | | | |--COMMA -> , [1549:49]
17757 | | | | |--EXPR -> EXPR [1549:51]
17758 | | | | | `--STRING_LITERAL -> "if rcurly" [1549:51]
17759 | | | | |--COMMA -> , [1549:62]
17760 | | | | |--EXPR -> EXPR [1549:64]
17761 | | | | | `--NUM_INT -> 9 [1549:64]
17762 | | | | |--COMMA -> , [1549:65]
17763 | | | | `--EXPR -> EXPR [1549:67]
17764 | | | | `--NUM_INT -> 8 [1549:67]
17765 | | | `--RPAREN -> ) [1549:68]
17766 | | |--COMMA -> , [1549:69]
17767 | | |--EXPR -> EXPR [1550:21]
17768 | | | `--PLUS -> + [1550:21]
17769 | | | |--STRING_LITERAL -> "93:8: " [1550:12]
17770 | | | `--METHOD_CALL -> ( [1550:38]
17771 | | | |--IDENT -> getCheckMessage [1550:23]
17772 | | | |--ELIST -> ELIST [1550:39]
17773 | | | | |--EXPR -> EXPR [1550:39]
17774 | | | | | `--IDENT -> MSG_ERROR [1550:39]
17775 | | | | |--COMMA -> , [1550:48]
17776 | | | | |--EXPR -> EXPR [1550:50]
17777 | | | | | `--STRING_LITERAL -> "else lcurly" [1550:50]
17778 | | | | |--COMMA -> , [1550:63]
17779 | | | | |--EXPR -> EXPR [1550:65]
17780 | | | | | `--NUM_INT -> 7 [1550:65]
17781 | | | | |--COMMA -> , [1550:66]
17782 | | | | `--EXPR -> EXPR [1550:68]
17783 | | | | `--NUM_INT -> 8 [1550:68]
17784 | | | `--RPAREN -> ) [1550:69]
17785 | | |--COMMA -> , [1550:70]
17786 | | |--EXPR -> EXPR [1551:22]
17787 | | | `--PLUS -> + [1551:22]
17788 | | | |--STRING_LITERAL -> "94:11: " [1551:12]
17789 | | | `--METHOD_CALL -> ( [1551:39]
17790 | | | |--IDENT -> getCheckMessage [1551:24]
17791 | | | |--ELIST -> ELIST [1551:40]
17792 | | | | |--EXPR -> EXPR [1551:40]
17793 | | | | | `--IDENT -> MSG_ERROR [1551:40]
17794 | | | | |--COMMA -> , [1551:49]
17795 | | | | |--EXPR -> EXPR [1551:51]
17796 | | | | | `--STRING_LITERAL -> "else rcurly" [1551:51]
17797 | | | | |--COMMA -> , [1551:64]
17798 | | | | |--EXPR -> EXPR [1551:66]
17799 | | | | | `--NUM_INT -> 10 [1551:66]
17800 | | | | |--COMMA -> , [1551:68]
17801 | | | | `--EXPR -> EXPR [1551:70]
17802 | | | | `--NUM_INT -> 8 [1551:70]
17803 | | | `--RPAREN -> ) [1551:71]
17804 | | |--COMMA -> , [1551:72]
17805 | | |--EXPR -> EXPR [1552:21]
17806 | | | `--PLUS -> + [1552:21]
17807 | | | |--STRING_LITERAL -> "97:7: " [1552:12]
17808 | | | `--METHOD_CALL -> ( [1552:38]
17809 | | | |--IDENT -> getCheckMessage [1552:23]
17810 | | | |--ELIST -> ELIST [1552:39]
17811 | | | | |--EXPR -> EXPR [1552:39]
17812 | | | | | `--IDENT -> MSG_ERROR [1552:39]
17813 | | | | |--COMMA -> , [1552:48]
17814 | | | | |--EXPR -> EXPR [1552:50]
17815 | | | | | `--STRING_LITERAL -> "if" [1552:50]
17816 | | | | |--COMMA -> , [1552:54]
17817 | | | | |--EXPR -> EXPR [1552:56]
17818 | | | | | `--NUM_INT -> 6 [1552:56]
17819 | | | | |--COMMA -> , [1552:57]
17820 | | | | `--EXPR -> EXPR [1552:59]
17821 | | | | `--NUM_INT -> 8 [1552:59]
17822 | | | `--RPAREN -> ) [1552:60]
17823 | | |--COMMA -> , [1552:61]
17824 | | |--EXPR -> EXPR [1553:22]
17825 | | | `--PLUS -> + [1553:22]
17826 | | | |--STRING_LITERAL -> "98:11: " [1553:12]
17827 | | | `--METHOD_CALL -> ( [1553:39]
17828 | | | |--IDENT -> getCheckMessage [1553:24]
17829 | | | |--ELIST -> ELIST [1553:40]
17830 | | | | |--EXPR -> EXPR [1553:40]
17831 | | | | | `--IDENT -> MSG_ERROR [1553:40]
17832 | | | | |--COMMA -> , [1553:49]
17833 | | | | |--EXPR -> EXPR [1553:51]
17834 | | | | | `--STRING_LITERAL -> "if lcurly" [1553:51]
17835 | | | | |--COMMA -> , [1553:62]
17836 | | | | |--EXPR -> EXPR [1553:64]
17837 | | | | | `--NUM_INT -> 10 [1553:64]
17838 | | | | |--COMMA -> , [1553:66]
17839 | | | | `--EXPR -> EXPR [1553:68]
17840 | | | | `--NUM_INT -> 8 [1553:68]
17841 | | | `--RPAREN -> ) [1553:69]
17842 | | |--COMMA -> , [1553:70]
17843 | | |--EXPR -> EXPR [1554:22]
17844 | | | `--PLUS -> + [1554:22]
17845 | | | |--STRING_LITERAL -> "99:11: " [1554:12]
17846 | | | `--METHOD_CALL -> ( [1554:39]
17847 | | | |--IDENT -> getCheckMessage [1554:24]
17848 | | | |--ELIST -> ELIST [1554:40]
17849 | | | | |--EXPR -> EXPR [1554:40]
17850 | | | | | `--IDENT -> MSG_ERROR [1554:40]
17851 | | | | |--COMMA -> , [1554:49]
17852 | | | | |--EXPR -> EXPR [1554:51]
17853 | | | | | `--STRING_LITERAL -> "if rcurly" [1554:51]
17854 | | | | |--COMMA -> , [1554:62]
17855 | | | | |--EXPR -> EXPR [1554:64]
17856 | | | | | `--NUM_INT -> 10 [1554:64]
17857 | | | | |--COMMA -> , [1554:66]
17858 | | | | `--EXPR -> EXPR [1554:68]
17859 | | | | `--NUM_INT -> 8 [1554:68]
17860 | | | `--RPAREN -> ) [1554:69]
17861 | | |--COMMA -> , [1554:70]
17862 | | |--EXPR -> EXPR [1555:22]
17863 | | | `--PLUS -> + [1555:22]
17864 | | | |--STRING_LITERAL -> "100:8: " [1555:12]
17865 | | | `--METHOD_CALL -> ( [1555:39]
17866 | | | |--IDENT -> getCheckMessage [1555:24]
17867 | | | |--ELIST -> ELIST [1555:40]
17868 | | | | |--EXPR -> EXPR [1555:40]
17869 | | | | | `--IDENT -> MSG_ERROR [1555:40]
17870 | | | | |--COMMA -> , [1555:49]
17871 | | | | |--EXPR -> EXPR [1555:51]
17872 | | | | | `--STRING_LITERAL -> "else rcurly" [1555:51]
17873 | | | | |--COMMA -> , [1555:64]
17874 | | | | |--EXPR -> EXPR [1555:66]
17875 | | | | | `--NUM_INT -> 7 [1555:66]
17876 | | | | |--COMMA -> , [1555:67]
17877 | | | | `--EXPR -> EXPR [1555:69]
17878 | | | | `--NUM_INT -> 8 [1555:69]
17879 | | | `--RPAREN -> ) [1555:70]
17880 | | |--COMMA -> , [1555:71]
17881 | | |--EXPR -> EXPR [1556:22]
17882 | | | `--PLUS -> + [1556:22]
17883 | | | |--STRING_LITERAL -> "103:6: " [1556:12]
17884 | | | `--METHOD_CALL -> ( [1556:39]
17885 | | | |--IDENT -> getCheckMessage [1556:24]
17886 | | | |--ELIST -> ELIST [1556:40]
17887 | | | | |--EXPR -> EXPR [1556:40]
17888 | | | | | `--IDENT -> MSG_ERROR [1556:40]
17889 | | | | |--COMMA -> , [1556:49]
17890 | | | | |--EXPR -> EXPR [1556:51]
17891 | | | | | `--STRING_LITERAL -> "if" [1556:51]
17892 | | | | |--COMMA -> , [1556:55]
17893 | | | | |--EXPR -> EXPR [1556:57]
17894 | | | | | `--NUM_INT -> 5 [1556:57]
17895 | | | | |--COMMA -> , [1556:58]
17896 | | | | `--EXPR -> EXPR [1556:60]
17897 | | | | `--NUM_INT -> 8 [1556:60]
17898 | | | `--RPAREN -> ) [1556:61]
17899 | | |--COMMA -> , [1556:62]
17900 | | |--EXPR -> EXPR [1557:23]
17901 | | | `--PLUS -> + [1557:23]
17902 | | | |--STRING_LITERAL -> "104:12: " [1557:12]
17903 | | | `--METHOD_CALL -> ( [1557:40]
17904 | | | |--IDENT -> getCheckMessage [1557:25]
17905 | | | |--ELIST -> ELIST [1557:41]
17906 | | | | |--EXPR -> EXPR [1557:41]
17907 | | | | | `--IDENT -> MSG_ERROR [1557:41]
17908 | | | | |--COMMA -> , [1557:50]
17909 | | | | |--EXPR -> EXPR [1557:52]
17910 | | | | | `--STRING_LITERAL -> "if rcurly" [1557:52]
17911 | | | | |--COMMA -> , [1557:63]
17912 | | | | |--EXPR -> EXPR [1557:65]
17913 | | | | | `--NUM_INT -> 11 [1557:65]
17914 | | | | |--COMMA -> , [1557:67]
17915 | | | | `--EXPR -> EXPR [1557:69]
17916 | | | | `--NUM_INT -> 8 [1557:69]
17917 | | | `--RPAREN -> ) [1557:70]
17918 | | |--COMMA -> , [1557:71]
17919 | | |--EXPR -> EXPR [1558:22]
17920 | | | `--PLUS -> + [1558:22]
17921 | | | |--STRING_LITERAL -> "105:6: " [1558:12]
17922 | | | `--METHOD_CALL -> ( [1558:39]
17923 | | | |--IDENT -> getCheckMessage [1558:24]
17924 | | | |--ELIST -> ELIST [1558:40]
17925 | | | | |--EXPR -> EXPR [1558:40]
17926 | | | | | `--IDENT -> MSG_ERROR [1558:40]
17927 | | | | |--COMMA -> , [1558:49]
17928 | | | | |--EXPR -> EXPR [1558:51]
17929 | | | | | `--STRING_LITERAL -> "else" [1558:51]
17930 | | | | |--COMMA -> , [1558:57]
17931 | | | | |--EXPR -> EXPR [1558:59]
17932 | | | | | `--NUM_INT -> 5 [1558:59]
17933 | | | | |--COMMA -> , [1558:60]
17934 | | | | `--EXPR -> EXPR [1558:62]
17935 | | | | `--NUM_INT -> 8 [1558:62]
17936 | | | `--RPAREN -> ) [1558:63]
17937 | | |--COMMA -> , [1558:64]
17938 | | |--EXPR -> EXPR [1559:23]
17939 | | | `--PLUS -> + [1559:23]
17940 | | | |--STRING_LITERAL -> "106:12: " [1559:12]
17941 | | | `--METHOD_CALL -> ( [1559:40]
17942 | | | |--IDENT -> getCheckMessage [1559:25]
17943 | | | |--ELIST -> ELIST [1559:41]
17944 | | | | |--EXPR -> EXPR [1559:41]
17945 | | | | | `--IDENT -> MSG_ERROR [1559:41]
17946 | | | | |--COMMA -> , [1559:50]
17947 | | | | |--EXPR -> EXPR [1559:52]
17948 | | | | | `--STRING_LITERAL -> "else rcurly" [1559:52]
17949 | | | | |--COMMA -> , [1559:65]
17950 | | | | |--EXPR -> EXPR [1559:67]
17951 | | | | | `--NUM_INT -> 11 [1559:67]
17952 | | | | |--COMMA -> , [1559:69]
17953 | | | | `--EXPR -> EXPR [1559:71]
17954 | | | | `--NUM_INT -> 8 [1559:71]
17955 | | | `--RPAREN -> ) [1559:72]
17956 | | |--COMMA -> , [1559:73]
17957 | | |--EXPR -> EXPR [1561:23]
17958 | | | `--PLUS -> + [1561:23]
17959 | | | |--STRING_LITERAL -> "126:15: " [1561:12]
17960 | | | `--METHOD_CALL -> ( [1561:40]
17961 | | | |--IDENT -> getCheckMessage [1561:25]
17962 | | | |--ELIST -> ELIST [1561:41]
17963 | | | | |--EXPR -> EXPR [1561:41]
17964 | | | | | `--IDENT -> MSG_CHILD_ERROR [1561:41]
17965 | | | | |--COMMA -> , [1561:56]
17966 | | | | |--EXPR -> EXPR [1561:58]
17967 | | | | | `--STRING_LITERAL -> "if" [1561:58]
17968 | | | | |--COMMA -> , [1561:62]
17969 | | | | |--EXPR -> EXPR [1561:64]
17970 | | | | | `--NUM_INT -> 14 [1561:64]
17971 | | | | |--COMMA -> , [1561:66]
17972 | | | | `--EXPR -> EXPR [1561:68]
17973 | | | | `--NUM_INT -> 12 [1561:68]
17974 | | | `--RPAREN -> ) [1561:70]
17975 | | |--COMMA -> , [1561:71]
17976 | | |--EXPR -> EXPR [1562:23]
17977 | | | `--PLUS -> + [1562:23]
17978 | | | |--STRING_LITERAL -> "131:11: " [1562:12]
17979 | | | `--METHOD_CALL -> ( [1562:40]
17980 | | | |--IDENT -> getCheckMessage [1562:25]
17981 | | | |--ELIST -> ELIST [1562:41]
17982 | | | | |--EXPR -> EXPR [1562:41]
17983 | | | | | `--IDENT -> MSG_ERROR [1562:41]
17984 | | | | |--COMMA -> , [1562:50]
17985 | | | | |--EXPR -> EXPR [1562:52]
17986 | | | | | `--STRING_LITERAL -> "if lcurly" [1562:52]
17987 | | | | |--COMMA -> , [1562:63]
17988 | | | | |--EXPR -> EXPR [1562:65]
17989 | | | | | `--NUM_INT -> 10 [1562:65]
17990 | | | | |--COMMA -> , [1562:67]
17991 | | | | `--EXPR -> EXPR [1562:69]
17992 | | | | `--NUM_INT -> 8 [1562:69]
17993 | | | `--RPAREN -> ) [1562:70]
17994 | | |--COMMA -> , [1562:71]
17995 | | |--EXPR -> EXPR [1563:23]
17996 | | | `--PLUS -> + [1563:23]
17997 | | | |--STRING_LITERAL -> "132:11: " [1563:12]
17998 | | | `--METHOD_CALL -> ( [1563:40]
17999 | | | |--IDENT -> getCheckMessage [1563:25]
18000 | | | |--ELIST -> ELIST [1563:41]
18001 | | | | |--EXPR -> EXPR [1563:41]
18002 | | | | | `--IDENT -> MSG_CHILD_ERROR [1563:41]
18003 | | | | |--COMMA -> , [1563:56]
18004 | | | | |--EXPR -> EXPR [1563:58]
18005 | | | | | `--STRING_LITERAL -> "if" [1563:58]
18006 | | | | |--COMMA -> , [1563:62]
18007 | | | | |--EXPR -> EXPR [1563:64]
18008 | | | | | `--NUM_INT -> 10 [1563:64]
18009 | | | | |--COMMA -> , [1563:66]
18010 | | | | `--EXPR -> EXPR [1563:68]
18011 | | | | `--NUM_INT -> 12 [1563:68]
18012 | | | `--RPAREN -> ) [1563:70]
18013 | | |--COMMA -> , [1563:71]
18014 | | |--EXPR -> EXPR [1564:23]
18015 | | | `--PLUS -> + [1564:23]
18016 | | | |--STRING_LITERAL -> "137:15: " [1564:12]
18017 | | | `--METHOD_CALL -> ( [1564:40]
18018 | | | |--IDENT -> getCheckMessage [1564:25]
18019 | | | |--ELIST -> ELIST [1564:41]
18020 | | | | |--EXPR -> EXPR [1564:41]
18021 | | | | | `--IDENT -> MSG_CHILD_ERROR [1564:41]
18022 | | | | |--COMMA -> , [1564:56]
18023 | | | | |--EXPR -> EXPR [1564:58]
18024 | | | | | `--STRING_LITERAL -> "if" [1564:58]
18025 | | | | |--COMMA -> , [1564:62]
18026 | | | | |--EXPR -> EXPR [1564:64]
18027 | | | | | `--NUM_INT -> 14 [1564:64]
18028 | | | | |--COMMA -> , [1564:66]
18029 | | | | `--EXPR -> EXPR [1564:68]
18030 | | | | `--NUM_INT -> 12 [1564:68]
18031 | | | `--RPAREN -> ) [1564:70]
18032 | | |--COMMA -> , [1564:71]
18033 | | |--EXPR -> EXPR [1565:23]
18034 | | | `--PLUS -> + [1565:23]
18035 | | | |--STRING_LITERAL -> "138:11: " [1565:12]
18036 | | | `--METHOD_CALL -> ( [1565:40]
18037 | | | |--IDENT -> getCheckMessage [1565:25]
18038 | | | |--ELIST -> ELIST [1565:41]
18039 | | | | |--EXPR -> EXPR [1565:41]
18040 | | | | | `--IDENT -> MSG_CHILD_ERROR [1565:41]
18041 | | | | |--COMMA -> , [1565:56]
18042 | | | | |--EXPR -> EXPR [1565:58]
18043 | | | | | `--STRING_LITERAL -> "method call" [1565:58]
18044 | | | | |--COMMA -> , [1565:71]
18045 | | | | |--EXPR -> EXPR [1565:73]
18046 | | | | | `--NUM_INT -> 10 [1565:73]
18047 | | | | |--COMMA -> , [1565:75]
18048 | | | | `--EXPR -> EXPR [1565:77]
18049 | | | | `--NUM_INT -> 12 [1565:77]
18050 | | | `--RPAREN -> ) [1565:79]
18051 | | |--COMMA -> , [1565:80]
18052 | | |--EXPR -> EXPR [1566:23]
18053 | | | `--PLUS -> + [1566:23]
18054 | | | |--STRING_LITERAL -> "140:11: " [1566:12]
18055 | | | `--METHOD_CALL -> ( [1566:40]
18056 | | | |--IDENT -> getCheckMessage [1566:25]
18057 | | | |--ELIST -> ELIST [1566:41]
18058 | | | | |--EXPR -> EXPR [1566:41]
18059 | | | | | `--IDENT -> MSG_CHILD_ERROR [1566:41]
18060 | | | | |--COMMA -> , [1566:56]
18061 | | | | |--EXPR -> EXPR [1566:58]
18062 | | | | | `--STRING_LITERAL -> "else" [1566:58]
18063 | | | | |--COMMA -> , [1566:64]
18064 | | | | |--EXPR -> EXPR [1566:66]
18065 | | | | | `--NUM_INT -> 10 [1566:66]
18066 | | | | |--COMMA -> , [1566:68]
18067 | | | | `--EXPR -> EXPR [1566:70]
18068 | | | | `--NUM_INT -> 12 [1566:70]
18069 | | | `--RPAREN -> ) [1566:72]
18070 | | |--COMMA -> , [1566:73]
18071 | | |--EXPR -> EXPR [1567:22]
18072 | | | `--PLUS -> + [1567:22]
18073 | | | |--STRING_LITERAL -> "141:9: " [1567:12]
18074 | | | `--METHOD_CALL -> ( [1567:39]
18075 | | | |--IDENT -> getCheckMessage [1567:24]
18076 | | | |--ELIST -> ELIST [1567:40]
18077 | | | | |--EXPR -> EXPR [1567:40]
18078 | | | | | `--IDENT -> MSG_CHILD_ERROR [1567:40]
18079 | | | | |--COMMA -> , [1567:55]
18080 | | | | |--EXPR -> EXPR [1567:57]
18081 | | | | | `--STRING_LITERAL -> "method call" [1567:57]
18082 | | | | |--COMMA -> , [1567:70]
18083 | | | | |--EXPR -> EXPR [1567:72]
18084 | | | | | `--NUM_INT -> 8 [1567:72]
18085 | | | | |--COMMA -> , [1567:73]
18086 | | | | `--EXPR -> EXPR [1567:75]
18087 | | | | `--NUM_INT -> 12 [1567:75]
18088 | | | `--RPAREN -> ) [1567:77]
18089 | | |--COMMA -> , [1567:78]
18090 | | |--EXPR -> EXPR [1569:23]
18091 | | | `--PLUS -> + [1569:23]
18092 | | | |--STRING_LITERAL -> "148:17: " [1569:12]
18093 | | | `--METHOD_CALL -> ( [1569:40]
18094 | | | |--IDENT -> getCheckMessage [1569:25]
18095 | | | |--ELIST -> ELIST [1569:41]
18096 | | | | |--EXPR -> EXPR [1569:41]
18097 | | | | | `--IDENT -> MSG_CHILD_ERROR [1569:41]
18098 | | | | |--COMMA -> , [1569:56]
18099 | | | | |--EXPR -> EXPR [1569:58]
18100 | | | | | `--STRING_LITERAL -> "if" [1569:58]
18101 | | | | |--COMMA -> , [1569:62]
18102 | | | | |--EXPR -> EXPR [1569:64]
18103 | | | | | `--NUM_INT -> 16 [1569:64]
18104 | | | | |--COMMA -> , [1569:66]
18105 | | | | `--EXPR -> EXPR [1569:68]
18106 | | | | `--NUM_INT -> 12 [1569:68]
18107 | | | `--RPAREN -> ) [1569:70]
18108 | | |--COMMA -> , [1569:71]
18109 | | |--EXPR -> EXPR [1570:23]
18110 | | | `--PLUS -> + [1570:23]
18111 | | | |--STRING_LITERAL -> "149:10: " [1570:12]
18112 | | | `--METHOD_CALL -> ( [1570:40]
18113 | | | |--IDENT -> getCheckMessage [1570:25]
18114 | | | |--ELIST -> ELIST [1570:41]
18115 | | | | |--EXPR -> EXPR [1570:41]
18116 | | | | | `--IDENT -> MSG_ERROR [1570:41]
18117 | | | | |--COMMA -> , [1570:50]
18118 | | | | |--EXPR -> EXPR [1570:52]
18119 | | | | | `--STRING_LITERAL -> "if rcurly" [1570:52]
18120 | | | | |--COMMA -> , [1570:63]
18121 | | | | |--EXPR -> EXPR [1570:65]
18122 | | | | | `--NUM_INT -> 9 [1570:65]
18123 | | | | |--COMMA -> , [1570:66]
18124 | | | | `--EXPR -> EXPR [1570:68]
18125 | | | | `--NUM_INT -> 8 [1570:68]
18126 | | | `--RPAREN -> ) [1570:69]
18127 | | |--COMMA -> , [1570:70]
18128 | | |--EXPR -> EXPR [1571:23]
18129 | | | `--PLUS -> + [1571:23]
18130 | | | |--STRING_LITERAL -> "152:17: " [1571:12]
18131 | | | `--METHOD_CALL -> ( [1571:40]
18132 | | | |--IDENT -> getCheckMessage [1571:25]
18133 | | | |--ELIST -> ELIST [1571:41]
18134 | | | | |--EXPR -> EXPR [1571:41]
18135 | | | | | `--IDENT -> MSG_CHILD_ERROR [1571:41]
18136 | | | | |--COMMA -> , [1571:56]
18137 | | | | |--EXPR -> EXPR [1571:58]
18138 | | | | | `--STRING_LITERAL -> "else" [1571:58]
18139 | | | | |--COMMA -> , [1571:64]
18140 | | | | |--EXPR -> EXPR [1571:66]
18141 | | | | | `--NUM_INT -> 16 [1571:66]
18142 | | | | |--COMMA -> , [1571:68]
18143 | | | | `--EXPR -> EXPR [1571:70]
18144 | | | | `--NUM_INT -> 12 [1571:70]
18145 | | | `--RPAREN -> ) [1571:72]
18146 | | |--COMMA -> , [1571:73]
18147 | | |--EXPR -> EXPR [1572:22]
18148 | | | `--PLUS -> + [1572:22]
18149 | | | |--STRING_LITERAL -> "158:1: " [1572:12]
18150 | | | `--METHOD_CALL -> ( [1572:39]
18151 | | | |--IDENT -> getCheckMessage [1572:24]
18152 | | | |--ELIST -> ELIST [1572:40]
18153 | | | | |--EXPR -> EXPR [1572:40]
18154 | | | | | `--IDENT -> MSG_CHILD_ERROR [1572:40]
18155 | | | | |--COMMA -> , [1572:55]
18156 | | | | |--EXPR -> EXPR [1572:57]
18157 | | | | | `--STRING_LITERAL -> "if" [1572:57]
18158 | | | | |--COMMA -> , [1572:61]
18159 | | | | |--EXPR -> EXPR [1572:63]
18160 | | | | | `--NUM_INT -> 0 [1572:63]
18161 | | | | |--COMMA -> , [1572:64]
18162 | | | | `--EXPR -> EXPR [1572:66]
18163 | | | | `--NUM_INT -> 12 [1572:66]
18164 | | | `--RPAREN -> ) [1572:68]
18165 | | |--COMMA -> , [1572:69]
18166 | | |--EXPR -> EXPR [1573:23]
18167 | | | `--PLUS -> + [1573:23]
18168 | | | |--STRING_LITERAL -> "162:41: " [1573:12]
18169 | | | `--METHOD_CALL -> ( [1573:40]
18170 | | | |--IDENT -> getCheckMessage [1573:25]
18171 | | | |--ELIST -> ELIST [1573:41]
18172 | | | | |--EXPR -> EXPR [1573:41]
18173 | | | | | `--IDENT -> MSG_CHILD_ERROR [1573:41]
18174 | | | | |--COMMA -> , [1573:56]
18175 | | | | |--EXPR -> EXPR [1573:58]
18176 | | | | | `--STRING_LITERAL -> "else" [1573:58]
18177 | | | | |--COMMA -> , [1573:64]
18178 | | | | |--EXPR -> EXPR [1573:66]
18179 | | | | | `--NUM_INT -> 40 [1573:66]
18180 | | | | |--COMMA -> , [1573:68]
18181 | | | | `--EXPR -> EXPR [1573:70]
18182 | | | | `--NUM_INT -> 12 [1573:70]
18183 | | | `--RPAREN -> ) [1573:72]
18184 | | |--COMMA -> , [1573:73]
18185 | | |--EXPR -> EXPR [1574:23]
18186 | | | `--PLUS -> + [1574:23]
18187 | | | |--STRING_LITERAL -> "169:15: " [1574:12]
18188 | | | `--METHOD_CALL -> ( [1574:40]
18189 | | | |--IDENT -> getCheckMessage [1574:25]
18190 | | | |--ELIST -> ELIST [1574:41]
18191 | | | | |--EXPR -> EXPR [1574:41]
18192 | | | | | `--IDENT -> MSG_CHILD_ERROR [1574:41]
18193 | | | | |--COMMA -> , [1574:56]
18194 | | | | |--EXPR -> EXPR [1574:58]
18195 | | | | | `--STRING_LITERAL -> "if" [1574:58]
18196 | | | | |--COMMA -> , [1574:62]
18197 | | | | |--EXPR -> EXPR [1574:64]
18198 | | | | | `--NUM_INT -> 14 [1574:64]
18199 | | | | |--COMMA -> , [1574:66]
18200 | | | | `--EXPR -> EXPR [1574:68]
18201 | | | | `--NUM_INT -> 12 [1574:68]
18202 | | | `--RPAREN -> ) [1574:70]
18203 | | |--COMMA -> , [1574:71]
18204 | | |--EXPR -> EXPR [1576:23]
18205 | | | `--PLUS -> + [1576:23]
18206 | | | |--STRING_LITERAL -> "172:15: " [1576:12]
18207 | | | `--METHOD_CALL -> ( [1576:40]
18208 | | | |--IDENT -> getCheckMessage [1576:25]
18209 | | | |--ELIST -> ELIST [1576:41]
18210 | | | | |--EXPR -> EXPR [1576:41]
18211 | | | | | `--IDENT -> MSG_CHILD_ERROR [1576:41]
18212 | | | | |--COMMA -> , [1576:56]
18213 | | | | |--EXPR -> EXPR [1576:58]
18214 | | | | | `--STRING_LITERAL -> "else" [1576:58]
18215 | | | | |--COMMA -> , [1576:64]
18216 | | | | |--EXPR -> EXPR [1576:66]
18217 | | | | | `--NUM_INT -> 14 [1576:66]
18218 | | | | |--COMMA -> , [1576:68]
18219 | | | | `--EXPR -> EXPR [1576:70]
18220 | | | | `--NUM_INT -> 12 [1576:70]
18221 | | | `--RPAREN -> ) [1576:72]
18222 | | |--COMMA -> , [1576:73]
18223 | | |--EXPR -> EXPR [1577:23]
18224 | | | `--PLUS -> + [1577:23]
18225 | | | |--STRING_LITERAL -> "178:11: " [1577:12]
18226 | | | `--METHOD_CALL -> ( [1577:40]
18227 | | | |--IDENT -> getCheckMessage [1577:25]
18228 | | | |--ELIST -> ELIST [1577:41]
18229 | | | | |--EXPR -> EXPR [1577:41]
18230 | | | | | `--IDENT -> MSG_CHILD_ERROR [1577:41]
18231 | | | | |--COMMA -> , [1577:56]
18232 | | | | |--EXPR -> EXPR [1577:58]
18233 | | | | | `--STRING_LITERAL -> "if" [1577:58]
18234 | | | | |--COMMA -> , [1577:62]
18235 | | | | |--EXPR -> EXPR [1577:64]
18236 | | | | | `--NUM_INT -> 10 [1577:64]
18237 | | | | |--COMMA -> , [1577:66]
18238 | | | | `--EXPR -> EXPR [1577:68]
18239 | | | | `--NUM_INT -> 12 [1577:68]
18240 | | | `--RPAREN -> ) [1577:70]
18241 | | |--COMMA -> , [1577:71]
18242 | | |--EXPR -> EXPR [1578:23]
18243 | | | `--PLUS -> + [1578:23]
18244 | | | |--STRING_LITERAL -> "180:11: " [1578:12]
18245 | | | `--METHOD_CALL -> ( [1578:40]
18246 | | | |--IDENT -> getCheckMessage [1578:25]
18247 | | | |--ELIST -> ELIST [1578:41]
18248 | | | | |--EXPR -> EXPR [1578:41]
18249 | | | | | `--IDENT -> MSG_CHILD_ERROR [1578:41]
18250 | | | | |--COMMA -> , [1578:56]
18251 | | | | |--EXPR -> EXPR [1578:58]
18252 | | | | | `--STRING_LITERAL -> "else" [1578:58]
18253 | | | | |--COMMA -> , [1578:64]
18254 | | | | |--EXPR -> EXPR [1578:66]
18255 | | | | | `--NUM_INT -> 10 [1578:66]
18256 | | | | |--COMMA -> , [1578:68]
18257 | | | | `--EXPR -> EXPR [1578:70]
18258 | | | | `--NUM_INT -> 12 [1578:70]
18259 | | | `--RPAREN -> ) [1578:72]
18260 | | |--COMMA -> , [1578:73]
18261 | | |--EXPR -> EXPR [1579:23]
18262 | | | `--PLUS -> + [1579:23]
18263 | | | |--STRING_LITERAL -> "184:11: " [1579:12]
18264 | | | `--METHOD_CALL -> ( [1579:40]
18265 | | | |--IDENT -> getCheckMessage [1579:25]
18266 | | | |--ELIST -> ELIST [1579:41]
18267 | | | | |--EXPR -> EXPR [1579:41]
18268 | | | | | `--IDENT -> MSG_ERROR [1579:41]
18269 | | | | |--COMMA -> , [1579:50]
18270 | | | | |--EXPR -> EXPR [1579:52]
18271 | | | | | `--STRING_LITERAL -> "if" [1579:52]
18272 | | | | |--COMMA -> , [1579:56]
18273 | | | | |--EXPR -> EXPR [1579:58]
18274 | | | | | `--NUM_INT -> 10 [1579:58]
18275 | | | | |--COMMA -> , [1579:60]
18276 | | | | `--EXPR -> EXPR [1579:62]
18277 | | | | `--NUM_INT -> 8 [1579:62]
18278 | | | `--RPAREN -> ) [1579:63]
18279 | | |--COMMA -> , [1579:64]
18280 | | |--EXPR -> EXPR [1580:23]
18281 | | | `--PLUS -> + [1580:23]
18282 | | | |--STRING_LITERAL -> "185:15: " [1580:12]
18283 | | | `--METHOD_CALL -> ( [1580:40]
18284 | | | |--IDENT -> getCheckMessage [1580:25]
18285 | | | |--ELIST -> ELIST [1580:41]
18286 | | | | |--EXPR -> EXPR [1580:41]
18287 | | | | | `--IDENT -> MSG_CHILD_ERROR [1580:41]
18288 | | | | |--COMMA -> , [1580:56]
18289 | | | | |--EXPR -> EXPR [1580:58]
18290 | | | | | `--STRING_LITERAL -> "if" [1580:58]
18291 | | | | |--COMMA -> , [1580:62]
18292 | | | | |--EXPR -> EXPR [1580:64]
18293 | | | | | `--NUM_INT -> 14 [1580:64]
18294 | | | | |--COMMA -> , [1580:66]
18295 | | | | `--EXPR -> EXPR [1580:68]
18296 | | | | `--NUM_INT -> 12 [1580:68]
18297 | | | `--RPAREN -> ) [1580:70]
18298 | | |--COMMA -> , [1580:71]
18299 | | |--EXPR -> EXPR [1581:23]
18300 | | | `--PLUS -> + [1581:23]
18301 | | | |--STRING_LITERAL -> "186:11: " [1581:12]
18302 | | | `--METHOD_CALL -> ( [1581:40]
18303 | | | |--IDENT -> getCheckMessage [1581:25]
18304 | | | |--ELIST -> ELIST [1581:41]
18305 | | | | |--EXPR -> EXPR [1581:41]
18306 | | | | | `--IDENT -> MSG_ERROR [1581:41]
18307 | | | | |--COMMA -> , [1581:50]
18308 | | | | |--EXPR -> EXPR [1581:52]
18309 | | | | | `--STRING_LITERAL -> "if rcurly" [1581:52]
18310 | | | | |--COMMA -> , [1581:63]
18311 | | | | |--EXPR -> EXPR [1581:65]
18312 | | | | | `--NUM_INT -> 10 [1581:65]
18313 | | | | |--COMMA -> , [1581:67]
18314 | | | | `--EXPR -> EXPR [1581:69]
18315 | | | | `--NUM_INT -> 8 [1581:69]
18316 | | | `--RPAREN -> ) [1581:70]
18317 | | |--COMMA -> , [1581:71]
18318 | | |--EXPR -> EXPR [1582:23]
18319 | | | `--PLUS -> + [1582:23]
18320 | | | |--STRING_LITERAL -> "187:11: " [1582:12]
18321 | | | `--METHOD_CALL -> ( [1582:40]
18322 | | | |--IDENT -> getCheckMessage [1582:25]
18323 | | | |--ELIST -> ELIST [1582:41]
18324 | | | | |--EXPR -> EXPR [1582:41]
18325 | | | | | `--IDENT -> MSG_ERROR [1582:41]
18326 | | | | |--COMMA -> , [1582:50]
18327 | | | | |--EXPR -> EXPR [1582:52]
18328 | | | | | `--STRING_LITERAL -> "else" [1582:52]
18329 | | | | |--COMMA -> , [1582:58]
18330 | | | | |--EXPR -> EXPR [1582:60]
18331 | | | | | `--NUM_INT -> 10 [1582:60]
18332 | | | | |--COMMA -> , [1582:62]
18333 | | | | `--EXPR -> EXPR [1582:64]
18334 | | | | `--NUM_INT -> 8 [1582:64]
18335 | | | `--RPAREN -> ) [1582:65]
18336 | | |--COMMA -> , [1582:66]
18337 | | |--EXPR -> EXPR [1584:23]
18338 | | | `--PLUS -> + [1584:23]
18339 | | | |--STRING_LITERAL -> "188:15: " [1584:12]
18340 | | | `--METHOD_CALL -> ( [1584:40]
18341 | | | |--IDENT -> getCheckMessage [1584:25]
18342 | | | |--ELIST -> ELIST [1584:41]
18343 | | | | |--EXPR -> EXPR [1584:41]
18344 | | | | | `--IDENT -> MSG_CHILD_ERROR [1584:41]
18345 | | | | |--COMMA -> , [1584:56]
18346 | | | | |--EXPR -> EXPR [1584:58]
18347 | | | | | `--STRING_LITERAL -> "else" [1584:58]
18348 | | | | |--COMMA -> , [1584:64]
18349 | | | | |--EXPR -> EXPR [1584:66]
18350 | | | | | `--NUM_INT -> 14 [1584:66]
18351 | | | | |--COMMA -> , [1584:68]
18352 | | | | `--EXPR -> EXPR [1584:70]
18353 | | | | `--NUM_INT -> 12 [1584:70]
18354 | | | `--RPAREN -> ) [1584:72]
18355 | | |--COMMA -> , [1584:73]
18356 | | |--EXPR -> EXPR [1585:23]
18357 | | | `--PLUS -> + [1585:23]
18358 | | | |--STRING_LITERAL -> "189:11: " [1585:12]
18359 | | | `--METHOD_CALL -> ( [1585:40]
18360 | | | |--IDENT -> getCheckMessage [1585:25]
18361 | | | |--ELIST -> ELIST [1585:41]
18362 | | | | |--EXPR -> EXPR [1585:41]
18363 | | | | | `--IDENT -> MSG_ERROR [1585:41]
18364 | | | | |--COMMA -> , [1585:50]
18365 | | | | |--EXPR -> EXPR [1585:52]
18366 | | | | | `--STRING_LITERAL -> "else rcurly" [1585:52]
18367 | | | | |--COMMA -> , [1585:65]
18368 | | | | |--EXPR -> EXPR [1585:67]
18369 | | | | | `--NUM_INT -> 10 [1585:67]
18370 | | | | |--COMMA -> , [1585:69]
18371 | | | | `--EXPR -> EXPR [1585:71]
18372 | | | | `--NUM_INT -> 8 [1585:71]
18373 | | | `--RPAREN -> ) [1585:72]
18374 | | |--COMMA -> , [1585:73]
18375 | | |--EXPR -> EXPR [1586:23]
18376 | | | `--PLUS -> + [1586:23]
18377 | | | |--STRING_LITERAL -> "192:10: " [1586:12]
18378 | | | `--METHOD_CALL -> ( [1586:40]
18379 | | | |--IDENT -> getCheckMessage [1586:25]
18380 | | | |--ELIST -> ELIST [1586:41]
18381 | | | | |--EXPR -> EXPR [1586:41]
18382 | | | | | `--IDENT -> MSG_CHILD_ERROR [1586:41]
18383 | | | | |--COMMA -> , [1586:56]
18384 | | | | |--EXPR -> EXPR [1586:58]
18385 | | | | | `--STRING_LITERAL -> "if" [1586:58]
18386 | | | | |--COMMA -> , [1586:62]
18387 | | | | |--EXPR -> EXPR [1586:64]
18388 | | | | | `--NUM_INT -> 9 [1586:64]
18389 | | | | |--COMMA -> , [1586:65]
18390 | | | | `--EXPR -> EXPR [1586:67]
18391 | | | | `--NUM_INT -> 12 [1586:67]
18392 | | | `--RPAREN -> ) [1586:69]
18393 | | |--COMMA -> , [1586:70]
18394 | | |--EXPR -> EXPR [1587:23]
18395 | | | `--PLUS -> + [1587:23]
18396 | | | |--STRING_LITERAL -> "193:12: " [1587:12]
18397 | | | `--METHOD_CALL -> ( [1587:40]
18398 | | | |--IDENT -> getCheckMessage [1587:25]
18399 | | | |--ELIST -> ELIST [1587:41]
18400 | | | | |--EXPR -> EXPR [1587:41]
18401 | | | | | `--IDENT -> MSG_CHILD_ERROR [1587:41]
18402 | | | | |--COMMA -> , [1587:56]
18403 | | | | |--EXPR -> EXPR [1587:58]
18404 | | | | | `--STRING_LITERAL -> "if" [1587:58]
18405 | | | | |--COMMA -> , [1587:62]
18406 | | | | |--EXPR -> EXPR [1587:64]
18407 | | | | | `--NUM_INT -> 11 [1587:64]
18408 | | | | |--COMMA -> , [1587:66]
18409 | | | | `--EXPR -> EXPR [1587:68]
18410 | | | | `--NUM_INT -> 12 [1587:68]
18411 | | | `--RPAREN -> ) [1587:70]
18412 | | |--COMMA -> , [1587:71]
18413 | | |--EXPR -> EXPR [1588:23]
18414 | | | `--PLUS -> + [1588:23]
18415 | | | |--STRING_LITERAL -> "197:11: " [1588:12]
18416 | | | `--METHOD_CALL -> ( [1588:40]
18417 | | | |--IDENT -> getCheckMessage [1588:25]
18418 | | | |--ELIST -> ELIST [1588:41]
18419 | | | | |--EXPR -> EXPR [1588:41]
18420 | | | | | `--IDENT -> MSG_CHILD_ERROR [1588:41]
18421 | | | | |--COMMA -> , [1588:56]
18422 | | | | |--EXPR -> EXPR [1588:58]
18423 | | | | | `--STRING_LITERAL -> "if" [1588:58]
18424 | | | | |--COMMA -> , [1588:62]
18425 | | | | |--EXPR -> EXPR [1588:64]
18426 | | | | | `--NUM_INT -> 10 [1588:64]
18427 | | | | |--COMMA -> , [1588:66]
18428 | | | | `--EXPR -> EXPR [1588:68]
18429 | | | | `--NUM_INT -> 12 [1588:68]
18430 | | | `--RPAREN -> ) [1588:70]
18431 | | |--COMMA -> , [1588:71]
18432 | | |--EXPR -> EXPR [1589:22]
18433 | | | `--PLUS -> + [1589:22]
18434 | | | |--STRING_LITERAL -> "200:8: " [1589:12]
18435 | | | `--METHOD_CALL -> ( [1589:39]
18436 | | | |--IDENT -> getCheckMessage [1589:24]
18437 | | | |--ELIST -> ELIST [1589:40]
18438 | | | | |--EXPR -> EXPR [1589:40]
18439 | | | | | `--IDENT -> MSG_ERROR [1589:40]
18440 | | | | |--COMMA -> , [1589:49]
18441 | | | | |--EXPR -> EXPR [1589:51]
18442 | | | | | `--STRING_LITERAL -> "if rcurly" [1589:51]
18443 | | | | |--COMMA -> , [1589:62]
18444 | | | | |--EXPR -> EXPR [1589:64]
18445 | | | | | `--NUM_INT -> 7 [1589:64]
18446 | | | | |--COMMA -> , [1589:65]
18447 | | | | `--EXPR -> EXPR [1589:67]
18448 | | | | `--NUM_INT -> 8 [1589:67]
18449 | | | `--RPAREN -> ) [1589:68]
18450 | | |--COMMA -> , [1589:69]
18451 | | |--EXPR -> EXPR [1590:23]
18452 | | | `--PLUS -> + [1590:23]
18453 | | | |--STRING_LITERAL -> "207:11: " [1590:12]
18454 | | | `--METHOD_CALL -> ( [1590:40]
18455 | | | |--IDENT -> getCheckMessage [1590:25]
18456 | | | |--ELIST -> ELIST [1590:41]
18457 | | | | |--EXPR -> EXPR [1590:41]
18458 | | | | | `--IDENT -> MSG_CHILD_ERROR [1590:41]
18459 | | | | |--COMMA -> , [1590:56]
18460 | | | | |--EXPR -> EXPR [1590:58]
18461 | | | | | `--STRING_LITERAL -> "if" [1590:58]
18462 | | | | |--COMMA -> , [1590:62]
18463 | | | | |--EXPR -> EXPR [1590:64]
18464 | | | | | `--NUM_INT -> 10 [1590:64]
18465 | | | | |--COMMA -> , [1590:66]
18466 | | | | `--EXPR -> EXPR [1590:68]
18467 | | | | `--NUM_INT -> 12 [1590:68]
18468 | | | `--RPAREN -> ) [1590:70]
18469 | | |--COMMA -> , [1590:71]
18470 | | |--EXPR -> EXPR [1591:23]
18471 | | | `--PLUS -> + [1591:23]
18472 | | | |--STRING_LITERAL -> "209:11: " [1591:12]
18473 | | | `--METHOD_CALL -> ( [1591:40]
18474 | | | |--IDENT -> getCheckMessage [1591:25]
18475 | | | |--ELIST -> ELIST [1591:41]
18476 | | | | |--EXPR -> EXPR [1591:41]
18477 | | | | | `--IDENT -> MSG_CHILD_ERROR [1591:41]
18478 | | | | |--COMMA -> , [1591:56]
18479 | | | | |--EXPR -> EXPR [1591:58]
18480 | | | | | `--STRING_LITERAL -> "if" [1591:58]
18481 | | | | |--COMMA -> , [1591:62]
18482 | | | | |--EXPR -> EXPR [1591:64]
18483 | | | | | `--NUM_INT -> 10 [1591:64]
18484 | | | | |--COMMA -> , [1591:66]
18485 | | | | `--EXPR -> EXPR [1591:68]
18486 | | | | `--NUM_INT -> 12 [1591:68]
18487 | | | `--RPAREN -> ) [1591:70]
18488 | | |--COMMA -> , [1591:71]
18489 | | |--EXPR -> EXPR [1593:23]
18490 | | | `--PLUS -> + [1593:23]
18491 | | | |--STRING_LITERAL -> "216:11: " [1593:12]
18492 | | | `--METHOD_CALL -> ( [1593:40]
18493 | | | |--IDENT -> getCheckMessage [1593:25]
18494 | | | |--ELIST -> ELIST [1593:41]
18495 | | | | |--EXPR -> EXPR [1593:41]
18496 | | | | | `--IDENT -> MSG_CHILD_ERROR [1593:41]
18497 | | | | |--COMMA -> , [1593:56]
18498 | | | | |--EXPR -> EXPR [1593:58]
18499 | | | | | `--STRING_LITERAL -> "if" [1593:58]
18500 | | | | |--COMMA -> , [1593:62]
18501 | | | | |--EXPR -> EXPR [1593:64]
18502 | | | | | `--NUM_INT -> 10 [1593:64]
18503 | | | | |--COMMA -> , [1593:66]
18504 | | | | `--EXPR -> EXPR [1593:68]
18505 | | | | `--NUM_INT -> 12 [1593:68]
18506 | | | `--RPAREN -> ) [1593:70]
18507 | | |--COMMA -> , [1593:71]
18508 | | |--EXPR -> EXPR [1594:23]
18509 | | | `--PLUS -> + [1594:23]
18510 | | | |--STRING_LITERAL -> "225:11: " [1594:12]
18511 | | | `--METHOD_CALL -> ( [1594:40]
18512 | | | |--IDENT -> getCheckMessage [1594:25]
18513 | | | |--ELIST -> ELIST [1594:41]
18514 | | | | |--EXPR -> EXPR [1594:41]
18515 | | | | | `--IDENT -> MSG_ERROR [1594:41]
18516 | | | | |--COMMA -> , [1594:50]
18517 | | | | |--EXPR -> EXPR [1594:52]
18518 | | | | | `--STRING_LITERAL -> "if" [1594:52]
18519 | | | | |--COMMA -> , [1594:56]
18520 | | | | |--EXPR -> EXPR [1594:58]
18521 | | | | | `--NUM_INT -> 10 [1594:58]
18522 | | | | |--COMMA -> , [1594:60]
18523 | | | | `--EXPR -> EXPR [1594:62]
18524 | | | | `--NUM_INT -> 12 [1594:62]
18525 | | | `--RPAREN -> ) [1594:64]
18526 | | |--COMMA -> , [1594:65]
18527 | | |--EXPR -> EXPR [1595:23]
18528 | | | `--PLUS -> + [1595:23]
18529 | | | |--STRING_LITERAL -> "229:19: " [1595:12]
18530 | | | `--METHOD_CALL -> ( [1595:40]
18531 | | | |--IDENT -> getCheckMessage [1595:25]
18532 | | | |--ELIST -> ELIST [1595:41]
18533 | | | | |--EXPR -> EXPR [1595:41]
18534 | | | | | `--IDENT -> MSG_CHILD_ERROR [1595:41]
18535 | | | | |--COMMA -> , [1595:56]
18536 | | | | |--EXPR -> EXPR [1595:58]
18537 | | | | | `--STRING_LITERAL -> "if" [1595:58]
18538 | | | | |--COMMA -> , [1595:62]
18539 | | | | |--EXPR -> EXPR [1595:64]
18540 | | | | | `--NUM_INT -> 18 [1595:64]
18541 | | | | |--COMMA -> , [1595:66]
18542 | | | | `--EXPR -> EXPR [1595:68]
18543 | | | | `--NUM_INT -> 20 [1595:68]
18544 | | | `--RPAREN -> ) [1595:70]
18545 | | |--COMMA -> , [1595:71]
18546 | | |--EXPR -> EXPR [1596:23]
18547 | | | `--PLUS -> + [1596:23]
18548 | | | |--STRING_LITERAL -> "240:11: " [1596:12]
18549 | | | `--METHOD_CALL -> ( [1596:40]
18550 | | | |--IDENT -> getCheckMessage [1596:25]
18551 | | | |--ELIST -> ELIST [1596:41]
18552 | | | | |--EXPR -> EXPR [1596:41]
18553 | | | | | `--IDENT -> MSG_ERROR [1596:41]
18554 | | | | |--COMMA -> , [1596:50]
18555 | | | | |--EXPR -> EXPR [1596:52]
18556 | | | | | `--STRING_LITERAL -> "if rparen" [1596:52]
18557 | | | | |--COMMA -> , [1596:63]
18558 | | | | |--EXPR -> EXPR [1596:65]
18559 | | | | | `--NUM_INT -> 10 [1596:65]
18560 | | | | |--COMMA -> , [1596:67]
18561 | | | | `--EXPR -> EXPR [1596:69]
18562 | | | | `--NUM_INT -> 8 [1596:69]
18563 | | | `--RPAREN -> ) [1596:70]
18564 | | |--COMMA -> , [1596:71]
18565 | | |--EXPR -> EXPR [1597:22]
18566 | | | `--PLUS -> + [1597:22]
18567 | | | |--STRING_LITERAL -> "245:7: " [1597:12]
18568 | | | `--METHOD_CALL -> ( [1597:39]
18569 | | | |--IDENT -> getCheckMessage [1597:24]
18570 | | | |--ELIST -> ELIST [1597:40]
18571 | | | | |--EXPR -> EXPR [1597:40]
18572 | | | | | `--IDENT -> MSG_ERROR [1597:40]
18573 | | | | |--COMMA -> , [1597:49]
18574 | | | | |--EXPR -> EXPR [1597:51]
18575 | | | | | `--STRING_LITERAL -> "if rparen" [1597:51]
18576 | | | | |--COMMA -> , [1597:62]
18577 | | | | |--EXPR -> EXPR [1597:64]
18578 | | | | | `--NUM_INT -> 6 [1597:64]
18579 | | | | |--COMMA -> , [1597:65]
18580 | | | | `--EXPR -> EXPR [1597:67]
18581 | | | | `--NUM_INT -> 8 [1597:67]
18582 | | | `--RPAREN -> ) [1597:68]
18583 | | |--COMMA -> , [1597:69]
18584 | | |--EXPR -> EXPR [1598:22]
18585 | | | `--PLUS -> + [1598:22]
18586 | | | |--STRING_LITERAL -> "251:7: " [1598:12]
18587 | | | `--METHOD_CALL -> ( [1598:39]
18588 | | | |--IDENT -> getCheckMessage [1598:24]
18589 | | | |--ELIST -> ELIST [1598:40]
18590 | | | | |--EXPR -> EXPR [1598:40]
18591 | | | | | `--IDENT -> MSG_ERROR [1598:40]
18592 | | | | |--COMMA -> , [1598:49]
18593 | | | | |--EXPR -> EXPR [1598:51]
18594 | | | | | `--STRING_LITERAL -> "if lparen" [1598:51]
18595 | | | | |--COMMA -> , [1598:62]
18596 | | | | |--EXPR -> EXPR [1598:64]
18597 | | | | | `--NUM_INT -> 6 [1598:64]
18598 | | | | |--COMMA -> , [1598:65]
18599 | | | | `--EXPR -> EXPR [1598:67]
18600 | | | | `--NUM_INT -> 8 [1598:67]
18601 | | | `--RPAREN -> ) [1598:68]
18602 | | |--COMMA -> , [1598:69]
18603 | | |--EXPR -> EXPR [1599:22]
18604 | | | `--PLUS -> + [1599:22]
18605 | | | |--STRING_LITERAL -> "253:7: " [1599:12]
18606 | | | `--METHOD_CALL -> ( [1599:39]
18607 | | | |--IDENT -> getCheckMessage [1599:24]
18608 | | | |--ELIST -> ELIST [1599:40]
18609 | | | | |--EXPR -> EXPR [1599:40]
18610 | | | | | `--IDENT -> MSG_ERROR [1599:40]
18611 | | | | |--COMMA -> , [1599:49]
18612 | | | | |--EXPR -> EXPR [1599:51]
18613 | | | | | `--STRING_LITERAL -> "if rparen" [1599:51]
18614 | | | | |--COMMA -> , [1599:62]
18615 | | | | |--EXPR -> EXPR [1599:64]
18616 | | | | | `--NUM_INT -> 6 [1599:64]
18617 | | | | |--COMMA -> , [1599:65]
18618 | | | | `--EXPR -> EXPR [1599:67]
18619 | | | | `--NUM_INT -> 8 [1599:67]
18620 | | | `--RPAREN -> ) [1599:68]
18621 | | |--COMMA -> , [1599:69]
18622 | | |--EXPR -> EXPR [1600:22]
18623 | | | `--PLUS -> + [1600:22]
18624 | | | |--STRING_LITERAL -> "256:1: " [1600:12]
18625 | | | `--METHOD_CALL -> ( [1600:39]
18626 | | | |--IDENT -> getCheckMessage [1600:24]
18627 | | | |--ELIST -> ELIST [1600:40]
18628 | | | | |--EXPR -> EXPR [1600:40]
18629 | | | | | `--IDENT -> MSG_ERROR [1600:40]
18630 | | | | |--COMMA -> , [1600:49]
18631 | | | | |--EXPR -> EXPR [1600:51]
18632 | | | | | `--STRING_LITERAL -> "if" [1600:51]
18633 | | | | |--COMMA -> , [1600:55]
18634 | | | | |--EXPR -> EXPR [1600:57]
18635 | | | | | `--NUM_INT -> 0 [1600:57]
18636 | | | | |--COMMA -> , [1600:58]
18637 | | | | `--EXPR -> EXPR [1600:60]
18638 | | | | `--NUM_INT -> 8 [1600:60]
18639 | | | `--RPAREN -> ) [1600:61]
18640 | | |--COMMA -> , [1600:62]
18641 | | |--EXPR -> EXPR [1601:22]
18642 | | | `--PLUS -> + [1601:22]
18643 | | | |--STRING_LITERAL -> "257:1: " [1601:12]
18644 | | | `--METHOD_CALL -> ( [1601:39]
18645 | | | |--IDENT -> getCheckMessage [1601:24]
18646 | | | |--ELIST -> ELIST [1601:40]
18647 | | | | |--EXPR -> EXPR [1601:40]
18648 | | | | | `--IDENT -> MSG_CHILD_ERROR [1601:40]
18649 | | | | |--COMMA -> , [1601:55]
18650 | | | | |--EXPR -> EXPR [1601:57]
18651 | | | | | `--STRING_LITERAL -> "if" [1601:57]
18652 | | | | |--COMMA -> , [1601:61]
18653 | | | | |--EXPR -> EXPR [1601:63]
18654 | | | | | `--NUM_INT -> 0 [1601:63]
18655 | | | | |--COMMA -> , [1601:64]
18656 | | | | `--EXPR -> EXPR [1601:66]
18657 | | | | `--NUM_INT -> 12 [1601:66]
18658 | | | `--RPAREN -> ) [1601:68]
18659 | | |--COMMA -> , [1601:69]
18660 | | |--EXPR -> EXPR [1602:22]
18661 | | | `--PLUS -> + [1602:22]
18662 | | | |--STRING_LITERAL -> "258:1: " [1602:12]
18663 | | | `--METHOD_CALL -> ( [1602:39]
18664 | | | |--IDENT -> getCheckMessage [1602:24]
18665 | | | |--ELIST -> ELIST [1602:40]
18666 | | | | |--EXPR -> EXPR [1602:40]
18667 | | | | | `--IDENT -> MSG_CHILD_ERROR [1602:40]
18668 | | | | |--COMMA -> , [1602:55]
18669 | | | | |--EXPR -> EXPR [1602:57]
18670 | | | | | `--STRING_LITERAL -> "if" [1602:57]
18671 | | | | |--COMMA -> , [1602:61]
18672 | | | | |--EXPR -> EXPR [1602:63]
18673 | | | | | `--NUM_INT -> 0 [1602:63]
18674 | | | | |--COMMA -> , [1602:64]
18675 | | | | `--EXPR -> EXPR [1602:66]
18676 | | | | `--NUM_INT -> 12 [1602:66]
18677 | | | `--RPAREN -> ) [1602:68]
18678 | | |--COMMA -> , [1602:69]
18679 | | |--EXPR -> EXPR [1603:22]
18680 | | | `--PLUS -> + [1603:22]
18681 | | | |--STRING_LITERAL -> "259:1: " [1603:12]
18682 | | | `--METHOD_CALL -> ( [1603:39]
18683 | | | |--IDENT -> getCheckMessage [1603:24]
18684 | | | |--ELIST -> ELIST [1603:40]
18685 | | | | |--EXPR -> EXPR [1603:40]
18686 | | | | | `--IDENT -> MSG_ERROR [1603:40]
18687 | | | | |--COMMA -> , [1603:49]
18688 | | | | |--EXPR -> EXPR [1603:51]
18689 | | | | | `--STRING_LITERAL -> "if rcurly" [1603:51]
18690 | | | | |--COMMA -> , [1603:62]
18691 | | | | |--EXPR -> EXPR [1603:64]
18692 | | | | | `--NUM_INT -> 0 [1603:64]
18693 | | | | |--COMMA -> , [1603:65]
18694 | | | | `--EXPR -> EXPR [1603:67]
18695 | | | | `--NUM_INT -> 8 [1603:67]
18696 | | | `--RPAREN -> ) [1603:68]
18697 | | |--COMMA -> , [1603:69]
18698 | | |--EXPR -> EXPR [1604:22]
18699 | | | `--PLUS -> + [1604:22]
18700 | | | |--STRING_LITERAL -> "260:1: " [1604:12]
18701 | | | `--METHOD_CALL -> ( [1604:39]
18702 | | | |--IDENT -> getCheckMessage [1604:24]
18703 | | | |--ELIST -> ELIST [1604:40]
18704 | | | | |--EXPR -> EXPR [1604:40]
18705 | | | | | `--IDENT -> MSG_ERROR [1604:40]
18706 | | | | |--COMMA -> , [1604:49]
18707 | | | | |--EXPR -> EXPR [1604:51]
18708 | | | | | `--STRING_LITERAL -> "if" [1604:51]
18709 | | | | |--COMMA -> , [1604:55]
18710 | | | | |--EXPR -> EXPR [1604:57]
18711 | | | | | `--NUM_INT -> 0 [1604:57]
18712 | | | | |--COMMA -> , [1604:58]
18713 | | | | `--EXPR -> EXPR [1604:60]
18714 | | | | `--NUM_INT -> 8 [1604:60]
18715 | | | `--RPAREN -> ) [1604:61]
18716 | | |--COMMA -> , [1604:62]
18717 | | |--EXPR -> EXPR [1605:22]
18718 | | | `--PLUS -> + [1605:22]
18719 | | | |--STRING_LITERAL -> "261:1: " [1605:12]
18720 | | | `--METHOD_CALL -> ( [1605:39]
18721 | | | |--IDENT -> getCheckMessage [1605:24]
18722 | | | |--ELIST -> ELIST [1605:40]
18723 | | | | |--EXPR -> EXPR [1605:40]
18724 | | | | | `--IDENT -> MSG_CHILD_ERROR [1605:40]
18725 | | | | |--COMMA -> , [1605:55]
18726 | | | | |--EXPR -> EXPR [1605:57]
18727 | | | | | `--STRING_LITERAL -> "if" [1605:57]
18728 | | | | |--COMMA -> , [1605:61]
18729 | | | | |--EXPR -> EXPR [1605:63]
18730 | | | | | `--NUM_INT -> 0 [1605:63]
18731 | | | | |--COMMA -> , [1605:64]
18732 | | | | `--EXPR -> EXPR [1605:66]
18733 | | | | `--NUM_INT -> 12 [1605:66]
18734 | | | `--RPAREN -> ) [1605:68]
18735 | | |--COMMA -> , [1605:69]
18736 | | |--EXPR -> EXPR [1606:22]
18737 | | | `--PLUS -> + [1606:22]
18738 | | | |--STRING_LITERAL -> "262:1: " [1606:12]
18739 | | | `--METHOD_CALL -> ( [1606:39]
18740 | | | |--IDENT -> getCheckMessage [1606:24]
18741 | | | |--ELIST -> ELIST [1606:40]
18742 | | | | |--EXPR -> EXPR [1606:40]
18743 | | | | | `--IDENT -> MSG_ERROR [1606:40]
18744 | | | | |--COMMA -> , [1606:49]
18745 | | | | |--EXPR -> EXPR [1606:51]
18746 | | | | | `--STRING_LITERAL -> "else" [1606:51]
18747 | | | | |--COMMA -> , [1606:57]
18748 | | | | |--EXPR -> EXPR [1606:59]
18749 | | | | | `--NUM_INT -> 0 [1606:59]
18750 | | | | |--COMMA -> , [1606:60]
18751 | | | | `--EXPR -> EXPR [1606:62]
18752 | | | | `--NUM_INT -> 8 [1606:62]
18753 | | | `--RPAREN -> ) [1606:63]
18754 | | |--COMMA -> , [1606:64]
18755 | | |--EXPR -> EXPR [1607:22]
18756 | | | `--PLUS -> + [1607:22]
18757 | | | |--STRING_LITERAL -> "263:1: " [1607:12]
18758 | | | `--METHOD_CALL -> ( [1607:39]
18759 | | | |--IDENT -> getCheckMessage [1607:24]
18760 | | | |--ELIST -> ELIST [1607:40]
18761 | | | | |--EXPR -> EXPR [1607:40]
18762 | | | | | `--IDENT -> MSG_CHILD_ERROR [1607:40]
18763 | | | | |--COMMA -> , [1607:55]
18764 | | | | |--EXPR -> EXPR [1607:57]
18765 | | | | | `--STRING_LITERAL -> "else" [1607:57]
18766 | | | | |--COMMA -> , [1607:63]
18767 | | | | |--EXPR -> EXPR [1607:65]
18768 | | | | | `--NUM_INT -> 0 [1607:65]
18769 | | | | |--COMMA -> , [1607:66]
18770 | | | | `--EXPR -> EXPR [1607:68]
18771 | | | | `--NUM_INT -> 12 [1607:68]
18772 | | | `--RPAREN -> ) [1607:70]
18773 | | |--COMMA -> , [1607:71]
18774 | | `--RCURLY -> } [1608:8]
18775 | |--SEMI -> ; [1608:9]
18776 | |--EXPR -> EXPR [1609:19]
18777 | | `--METHOD_CALL -> ( [1609:19]
18778 | | |--IDENT -> verifyWarns [1609:8]
18779 | | |--ELIST -> ELIST [1609:20]
18780 | | | |--EXPR -> EXPR [1609:20]
18781 | | | | `--IDENT -> checkConfig [1609:20]
18782 | | | |--COMMA -> , [1609:31]
18783 | | | |--EXPR -> EXPR [1609:33]
18784 | | | | `--IDENT -> fileName [1609:33]
18785 | | | |--COMMA -> , [1609:41]
18786 | | | `--EXPR -> EXPR [1609:43]
18787 | | | `--IDENT -> expected [1609:43]
18788 | | `--RPAREN -> ) [1609:51]
18789 | |--SEMI -> ; [1609:52]
18790 | `--RCURLY -> } [1610:4]
18791 |--METHOD_DEF -> METHOD_DEF [1612:4]
18792 | |--MODIFIERS -> MODIFIERS [1612:4]
18793 | | |--ANNOTATION -> ANNOTATION [1612:4]
18794 | | | |--AT -> @ [1612:4]
18795 | | | `--IDENT -> Test [1612:5]
18796 | | `--LITERAL_PUBLIC -> public [1613:4]
18797 | |--TYPE -> TYPE [1613:11]
18798 | | `--LITERAL_VOID -> void [1613:11]
18799 | |--IDENT -> testInvalidWhileWithChecker [1613:16]
18800 | |--LPAREN -> ( [1613:43]
18801 | |--PARAMETERS -> PARAMETERS [1613:44]
18802 | |--RPAREN -> ) [1613:44]
18803 | |--LITERAL_THROWS -> throws [1614:12]
18804 | | `--IDENT -> Exception [1614:19]
18805 | `--SLIST -> { [1614:29]
18806 | |--VARIABLE_DEF -> VARIABLE_DEF [1615:8]
18807 | | |--MODIFIERS -> MODIFIERS [1615:8]
18808 | | | `--FINAL -> final [1615:8]
18809 | | |--TYPE -> TYPE [1615:14]
18810 | | | `--IDENT -> DefaultConfiguration [1615:14]
18811 | | |--IDENT -> checkConfig [1615:35]
18812 | | `--ASSIGN -> = [1615:47]
18813 | | `--EXPR -> EXPR [1615:67]
18814 | | `--METHOD_CALL -> ( [1615:67]
18815 | | |--IDENT -> createModuleConfig [1615:49]
18816 | | |--ELIST -> ELIST [1615:84]
18817 | | | `--EXPR -> EXPR [1615:84]
18818 | | | `--DOT -> . [1615:84]
18819 | | | |--IDENT -> IndentationCheck [1615:68]
18820 | | | `--LITERAL_CLASS -> class [1615:85]
18821 | | `--RPAREN -> ) [1615:90]
18822 | |--SEMI -> ; [1615:91]
18823 | |--EXPR -> EXPR [1617:32]
18824 | | `--METHOD_CALL -> ( [1617:32]
18825 | | |--DOT -> . [1617:19]
18826 | | | |--IDENT -> checkConfig [1617:8]
18827 | | | `--IDENT -> addAttribute [1617:20]
18828 | | |--ELIST -> ELIST [1617:33]
18829 | | | |--EXPR -> EXPR [1617:33]
18830 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1617:33]
18831 | | | |--COMMA -> , [1617:50]
18832 | | | `--EXPR -> EXPR [1617:52]
18833 | | | `--STRING_LITERAL -> "4" [1617:52]
18834 | | `--RPAREN -> ) [1617:55]
18835 | |--SEMI -> ; [1617:56]
18836 | |--EXPR -> EXPR [1618:32]
18837 | | `--METHOD_CALL -> ( [1618:32]
18838 | | |--DOT -> . [1618:19]
18839 | | | |--IDENT -> checkConfig [1618:8]
18840 | | | `--IDENT -> addAttribute [1618:20]
18841 | | |--ELIST -> ELIST [1618:33]
18842 | | | |--EXPR -> EXPR [1618:33]
18843 | | | | `--STRING_LITERAL -> "basicOffset" [1618:33]
18844 | | | |--COMMA -> , [1618:46]
18845 | | | `--EXPR -> EXPR [1618:48]
18846 | | | `--STRING_LITERAL -> "4" [1618:48]
18847 | | `--RPAREN -> ) [1618:51]
18848 | |--SEMI -> ; [1618:52]
18849 | |--EXPR -> EXPR [1619:32]
18850 | | `--METHOD_CALL -> ( [1619:32]
18851 | | |--DOT -> . [1619:19]
18852 | | | |--IDENT -> checkConfig [1619:8]
18853 | | | `--IDENT -> addAttribute [1619:20]
18854 | | |--ELIST -> ELIST [1619:33]
18855 | | | |--EXPR -> EXPR [1619:33]
18856 | | | | `--STRING_LITERAL -> "braceAdjustment" [1619:33]
18857 | | | |--COMMA -> , [1619:50]
18858 | | | `--EXPR -> EXPR [1619:52]
18859 | | | `--STRING_LITERAL -> "0" [1619:52]
18860 | | `--RPAREN -> ) [1619:55]
18861 | |--SEMI -> ; [1619:56]
18862 | |--EXPR -> EXPR [1620:32]
18863 | | `--METHOD_CALL -> ( [1620:32]
18864 | | |--DOT -> . [1620:19]
18865 | | | |--IDENT -> checkConfig [1620:8]
18866 | | | `--IDENT -> addAttribute [1620:20]
18867 | | |--ELIST -> ELIST [1620:33]
18868 | | | |--EXPR -> EXPR [1620:33]
18869 | | | | `--STRING_LITERAL -> "caseIndent" [1620:33]
18870 | | | |--COMMA -> , [1620:45]
18871 | | | `--EXPR -> EXPR [1620:47]
18872 | | | `--STRING_LITERAL -> "4" [1620:47]
18873 | | `--RPAREN -> ) [1620:50]
18874 | |--SEMI -> ; [1620:51]
18875 | |--EXPR -> EXPR [1621:32]
18876 | | `--METHOD_CALL -> ( [1621:32]
18877 | | |--DOT -> . [1621:19]
18878 | | | |--IDENT -> checkConfig [1621:8]
18879 | | | `--IDENT -> addAttribute [1621:20]
18880 | | |--ELIST -> ELIST [1621:33]
18881 | | | |--EXPR -> EXPR [1621:33]
18882 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1621:33]
18883 | | | |--COMMA -> , [1621:55]
18884 | | | `--EXPR -> EXPR [1621:57]
18885 | | | `--STRING_LITERAL -> "false" [1621:57]
18886 | | `--RPAREN -> ) [1621:64]
18887 | |--SEMI -> ; [1621:65]
18888 | |--EXPR -> EXPR [1622:32]
18889 | | `--METHOD_CALL -> ( [1622:32]
18890 | | |--DOT -> . [1622:19]
18891 | | | |--IDENT -> checkConfig [1622:8]
18892 | | | `--IDENT -> addAttribute [1622:20]
18893 | | |--ELIST -> ELIST [1622:33]
18894 | | | |--EXPR -> EXPR [1622:33]
18895 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1622:33]
18896 | | | |--COMMA -> , [1622:58]
18897 | | | `--EXPR -> EXPR [1622:60]
18898 | | | `--STRING_LITERAL -> "4" [1622:60]
18899 | | `--RPAREN -> ) [1622:63]
18900 | |--SEMI -> ; [1622:64]
18901 | |--EXPR -> EXPR [1623:32]
18902 | | `--METHOD_CALL -> ( [1623:32]
18903 | | |--DOT -> . [1623:19]
18904 | | | |--IDENT -> checkConfig [1623:8]
18905 | | | `--IDENT -> addAttribute [1623:20]
18906 | | |--ELIST -> ELIST [1623:33]
18907 | | | |--EXPR -> EXPR [1623:33]
18908 | | | | `--STRING_LITERAL -> "tabWidth" [1623:33]
18909 | | | |--COMMA -> , [1623:43]
18910 | | | `--EXPR -> EXPR [1623:45]
18911 | | | `--STRING_LITERAL -> "4" [1623:45]
18912 | | `--RPAREN -> ) [1623:48]
18913 | |--SEMI -> ; [1623:49]
18914 | |--EXPR -> EXPR [1624:32]
18915 | | `--METHOD_CALL -> ( [1624:32]
18916 | | |--DOT -> . [1624:19]
18917 | | | |--IDENT -> checkConfig [1624:8]
18918 | | | `--IDENT -> addAttribute [1624:20]
18919 | | |--ELIST -> ELIST [1624:33]
18920 | | | |--EXPR -> EXPR [1624:33]
18921 | | | | `--STRING_LITERAL -> "throwsIndent" [1624:33]
18922 | | | |--COMMA -> , [1624:47]
18923 | | | `--EXPR -> EXPR [1624:49]
18924 | | | `--STRING_LITERAL -> "4" [1624:49]
18925 | | `--RPAREN -> ) [1624:52]
18926 | |--SEMI -> ; [1624:53]
18927 | |--VARIABLE_DEF -> VARIABLE_DEF [1625:8]
18928 | | |--MODIFIERS -> MODIFIERS [1625:8]
18929 | | | `--FINAL -> final [1625:8]
18930 | | |--TYPE -> TYPE [1625:14]
18931 | | | `--IDENT -> String [1625:14]
18932 | | |--IDENT -> fileName [1625:21]
18933 | | `--ASSIGN -> = [1625:30]
18934 | | `--EXPR -> EXPR [1625:39]
18935 | | `--METHOD_CALL -> ( [1625:39]
18936 | | |--IDENT -> getPath [1625:32]
18937 | | |--ELIST -> ELIST [1625:40]
18938 | | | `--EXPR -> EXPR [1625:40]
18939 | | | `--STRING_LITERAL -> "InputIndentationInvalidWhileIndent.java" [1625:40]
18940 | | `--RPAREN -> ) [1625:81]
18941 | |--SEMI -> ; [1625:82]
18942 | |--VARIABLE_DEF -> VARIABLE_DEF [1626:8]
18943 | | |--MODIFIERS -> MODIFIERS [1626:8]
18944 | | | `--FINAL -> final [1626:8]
18945 | | |--TYPE -> TYPE [1626:20]
18946 | | | `--ARRAY_DECLARATOR -> [ [1626:20]
18947 | | | |--IDENT -> String [1626:14]
18948 | | | `--RBRACK -> ] [1626:21]
18949 | | |--IDENT -> expected [1626:23]
18950 | | `--ASSIGN -> = [1626:32]
18951 | | `--ARRAY_INIT -> { [1626:34]
18952 | | |--EXPR -> EXPR [1627:22]
18953 | | | `--PLUS -> + [1627:22]
18954 | | | |--STRING_LITERAL -> "25:10: " [1627:12]
18955 | | | `--METHOD_CALL -> ( [1627:39]
18956 | | | |--IDENT -> getCheckMessage [1627:24]
18957 | | | |--ELIST -> ELIST [1627:40]
18958 | | | | |--EXPR -> EXPR [1627:40]
18959 | | | | | `--IDENT -> MSG_ERROR [1627:40]
18960 | | | | |--COMMA -> , [1627:49]
18961 | | | | |--EXPR -> EXPR [1627:51]
18962 | | | | | `--STRING_LITERAL -> "while" [1627:51]
18963 | | | | |--COMMA -> , [1627:58]
18964 | | | | |--EXPR -> EXPR [1627:60]
18965 | | | | | `--NUM_INT -> 9 [1627:60]
18966 | | | | |--COMMA -> , [1627:61]
18967 | | | | `--EXPR -> EXPR [1627:63]
18968 | | | | `--NUM_INT -> 8 [1627:63]
18969 | | | `--RPAREN -> ) [1627:64]
18970 | | |--COMMA -> , [1627:65]
18971 | | |--EXPR -> EXPR [1628:21]
18972 | | | `--PLUS -> + [1628:21]
18973 | | | |--STRING_LITERAL -> "26:8: " [1628:12]
18974 | | | `--METHOD_CALL -> ( [1628:38]
18975 | | | |--IDENT -> getCheckMessage [1628:23]
18976 | | | |--ELIST -> ELIST [1628:39]
18977 | | | | |--EXPR -> EXPR [1628:39]
18978 | | | | | `--IDENT -> MSG_ERROR [1628:39]
18979 | | | | |--COMMA -> , [1628:48]
18980 | | | | |--EXPR -> EXPR [1628:50]
18981 | | | | | `--STRING_LITERAL -> "while rcurly" [1628:50]
18982 | | | | |--COMMA -> , [1628:64]
18983 | | | | |--EXPR -> EXPR [1628:66]
18984 | | | | | `--NUM_INT -> 7 [1628:66]
18985 | | | | |--COMMA -> , [1628:67]
18986 | | | | `--EXPR -> EXPR [1628:69]
18987 | | | | `--NUM_INT -> 8 [1628:69]
18988 | | | `--RPAREN -> ) [1628:70]
18989 | | |--COMMA -> , [1628:71]
18990 | | |--EXPR -> EXPR [1629:21]
18991 | | | `--PLUS -> + [1629:21]
18992 | | | |--STRING_LITERAL -> "28:8: " [1629:12]
18993 | | | `--METHOD_CALL -> ( [1629:38]
18994 | | | |--IDENT -> getCheckMessage [1629:23]
18995 | | | |--ELIST -> ELIST [1629:39]
18996 | | | | |--EXPR -> EXPR [1629:39]
18997 | | | | | `--IDENT -> MSG_ERROR [1629:39]
18998 | | | | |--COMMA -> , [1629:48]
18999 | | | | |--EXPR -> EXPR [1629:50]
19000 | | | | | `--STRING_LITERAL -> "while" [1629:50]
19001 | | | | |--COMMA -> , [1629:57]
19002 | | | | |--EXPR -> EXPR [1629:59]
19003 | | | | | `--NUM_INT -> 7 [1629:59]
19004 | | | | |--COMMA -> , [1629:60]
19005 | | | | `--EXPR -> EXPR [1629:62]
19006 | | | | `--NUM_INT -> 8 [1629:62]
19007 | | | `--RPAREN -> ) [1629:63]
19008 | | |--COMMA -> , [1629:64]
19009 | | |--EXPR -> EXPR [1630:22]
19010 | | | `--PLUS -> + [1630:22]
19011 | | | |--STRING_LITERAL -> "29:10: " [1630:12]
19012 | | | `--METHOD_CALL -> ( [1630:39]
19013 | | | |--IDENT -> getCheckMessage [1630:24]
19014 | | | |--ELIST -> ELIST [1630:40]
19015 | | | | |--EXPR -> EXPR [1630:40]
19016 | | | | | `--IDENT -> MSG_ERROR [1630:40]
19017 | | | | |--COMMA -> , [1630:49]
19018 | | | | |--EXPR -> EXPR [1630:51]
19019 | | | | | `--STRING_LITERAL -> "while lcurly" [1630:51]
19020 | | | | |--COMMA -> , [1630:65]
19021 | | | | |--EXPR -> EXPR [1630:67]
19022 | | | | | `--NUM_INT -> 9 [1630:67]
19023 | | | | |--COMMA -> , [1630:68]
19024 | | | | `--EXPR -> EXPR [1630:70]
19025 | | | | `--NUM_INT -> 8 [1630:70]
19026 | | | `--RPAREN -> ) [1630:71]
19027 | | |--COMMA -> , [1630:72]
19028 | | |--EXPR -> EXPR [1631:22]
19029 | | | `--PLUS -> + [1631:22]
19030 | | | |--STRING_LITERAL -> "30:10: " [1631:12]
19031 | | | `--METHOD_CALL -> ( [1631:39]
19032 | | | |--IDENT -> getCheckMessage [1631:24]
19033 | | | |--ELIST -> ELIST [1631:40]
19034 | | | | |--EXPR -> EXPR [1631:40]
19035 | | | | | `--IDENT -> MSG_ERROR [1631:40]
19036 | | | | |--COMMA -> , [1631:49]
19037 | | | | |--EXPR -> EXPR [1631:51]
19038 | | | | | `--STRING_LITERAL -> "while rcurly" [1631:51]
19039 | | | | |--COMMA -> , [1631:65]
19040 | | | | |--EXPR -> EXPR [1631:67]
19041 | | | | | `--NUM_INT -> 9 [1631:67]
19042 | | | | |--COMMA -> , [1631:68]
19043 | | | | `--EXPR -> EXPR [1631:70]
19044 | | | | `--NUM_INT -> 8 [1631:70]
19045 | | | `--RPAREN -> ) [1631:71]
19046 | | |--COMMA -> , [1631:72]
19047 | | |--EXPR -> EXPR [1633:22]
19048 | | | `--PLUS -> + [1633:22]
19049 | | | |--STRING_LITERAL -> "32:10: " [1633:12]
19050 | | | `--METHOD_CALL -> ( [1633:39]
19051 | | | |--IDENT -> getCheckMessage [1633:24]
19052 | | | |--ELIST -> ELIST [1633:40]
19053 | | | | |--EXPR -> EXPR [1633:40]
19054 | | | | | `--IDENT -> MSG_ERROR [1633:40]
19055 | | | | |--COMMA -> , [1633:49]
19056 | | | | |--EXPR -> EXPR [1633:51]
19057 | | | | | `--STRING_LITERAL -> "while" [1633:51]
19058 | | | | |--COMMA -> , [1633:58]
19059 | | | | |--EXPR -> EXPR [1633:60]
19060 | | | | | `--NUM_INT -> 9 [1633:60]
19061 | | | | |--COMMA -> , [1633:61]
19062 | | | | `--EXPR -> EXPR [1633:63]
19063 | | | | `--NUM_INT -> 8 [1633:63]
19064 | | | `--RPAREN -> ) [1633:64]
19065 | | |--COMMA -> , [1633:65]
19066 | | |--EXPR -> EXPR [1634:21]
19067 | | | `--PLUS -> + [1634:21]
19068 | | | |--STRING_LITERAL -> "33:7: " [1634:12]
19069 | | | `--METHOD_CALL -> ( [1634:38]
19070 | | | |--IDENT -> getCheckMessage [1634:23]
19071 | | | |--ELIST -> ELIST [1634:39]
19072 | | | | |--EXPR -> EXPR [1634:39]
19073 | | | | | `--IDENT -> MSG_ERROR [1634:39]
19074 | | | | |--COMMA -> , [1634:48]
19075 | | | | |--EXPR -> EXPR [1634:50]
19076 | | | | | `--STRING_LITERAL -> "while lcurly" [1634:50]
19077 | | | | |--COMMA -> , [1634:64]
19078 | | | | |--EXPR -> EXPR [1634:66]
19079 | | | | | `--NUM_INT -> 6 [1634:66]
19080 | | | | |--COMMA -> , [1634:67]
19081 | | | | `--EXPR -> EXPR [1634:69]
19082 | | | | `--NUM_INT -> 8 [1634:69]
19083 | | | `--RPAREN -> ) [1634:70]
19084 | | |--COMMA -> , [1634:71]
19085 | | |--EXPR -> EXPR [1635:22]
19086 | | | `--PLUS -> + [1635:22]
19087 | | | |--STRING_LITERAL -> "34:15: " [1635:12]
19088 | | | `--METHOD_CALL -> ( [1635:39]
19089 | | | |--IDENT -> getCheckMessage [1635:24]
19090 | | | |--ELIST -> ELIST [1635:40]
19091 | | | | |--EXPR -> EXPR [1635:40]
19092 | | | | | `--IDENT -> MSG_CHILD_ERROR [1635:40]
19093 | | | | |--COMMA -> , [1635:55]
19094 | | | | |--EXPR -> EXPR [1635:57]
19095 | | | | | `--STRING_LITERAL -> "while" [1635:57]
19096 | | | | |--COMMA -> , [1635:64]
19097 | | | | |--EXPR -> EXPR [1635:66]
19098 | | | | | `--NUM_INT -> 14 [1635:66]
19099 | | | | |--COMMA -> , [1635:68]
19100 | | | | `--EXPR -> EXPR [1635:70]
19101 | | | | `--NUM_INT -> 12 [1635:70]
19102 | | | `--RPAREN -> ) [1635:72]
19103 | | |--COMMA -> , [1635:73]
19104 | | |--EXPR -> EXPR [1636:21]
19105 | | | `--PLUS -> + [1636:21]
19106 | | | |--STRING_LITERAL -> "35:7: " [1636:12]
19107 | | | `--METHOD_CALL -> ( [1636:38]
19108 | | | |--IDENT -> getCheckMessage [1636:23]
19109 | | | |--ELIST -> ELIST [1636:39]
19110 | | | | |--EXPR -> EXPR [1636:39]
19111 | | | | | `--IDENT -> MSG_ERROR [1636:39]
19112 | | | | |--COMMA -> , [1636:48]
19113 | | | | |--EXPR -> EXPR [1636:50]
19114 | | | | | `--STRING_LITERAL -> "while rcurly" [1636:50]
19115 | | | | |--COMMA -> , [1636:64]
19116 | | | | |--EXPR -> EXPR [1636:66]
19117 | | | | | `--NUM_INT -> 6 [1636:66]
19118 | | | | |--COMMA -> , [1636:67]
19119 | | | | `--EXPR -> EXPR [1636:69]
19120 | | | | `--NUM_INT -> 8 [1636:69]
19121 | | | `--RPAREN -> ) [1636:70]
19122 | | |--COMMA -> , [1636:71]
19123 | | |--EXPR -> EXPR [1638:22]
19124 | | | `--PLUS -> + [1638:22]
19125 | | | |--STRING_LITERAL -> "37:11: " [1638:12]
19126 | | | `--METHOD_CALL -> ( [1638:39]
19127 | | | |--IDENT -> getCheckMessage [1638:24]
19128 | | | |--ELIST -> ELIST [1638:40]
19129 | | | | |--EXPR -> EXPR [1638:40]
19130 | | | | | `--IDENT -> MSG_ERROR [1638:40]
19131 | | | | |--COMMA -> , [1638:49]
19132 | | | | |--EXPR -> EXPR [1638:51]
19133 | | | | | `--STRING_LITERAL -> "while" [1638:51]
19134 | | | | |--COMMA -> , [1638:58]
19135 | | | | |--EXPR -> EXPR [1638:60]
19136 | | | | | `--NUM_INT -> 10 [1638:60]
19137 | | | | |--COMMA -> , [1638:62]
19138 | | | | `--EXPR -> EXPR [1638:64]
19139 | | | | `--NUM_INT -> 8 [1638:64]
19140 | | | `--RPAREN -> ) [1638:65]
19141 | | |--COMMA -> , [1638:66]
19142 | | |--EXPR -> EXPR [1639:22]
19143 | | | `--PLUS -> + [1639:22]
19144 | | | |--STRING_LITERAL -> "39:11: " [1639:12]
19145 | | | `--METHOD_CALL -> ( [1639:39]
19146 | | | |--IDENT -> getCheckMessage [1639:24]
19147 | | | |--ELIST -> ELIST [1639:40]
19148 | | | | |--EXPR -> EXPR [1639:40]
19149 | | | | | `--IDENT -> MSG_ERROR [1639:40]
19150 | | | | |--COMMA -> , [1639:49]
19151 | | | | |--EXPR -> EXPR [1639:51]
19152 | | | | | `--STRING_LITERAL -> "while rcurly" [1639:51]
19153 | | | | |--COMMA -> , [1639:65]
19154 | | | | |--EXPR -> EXPR [1639:67]
19155 | | | | | `--NUM_INT -> 10 [1639:67]
19156 | | | | |--COMMA -> , [1639:69]
19157 | | | | `--EXPR -> EXPR [1639:71]
19158 | | | | `--NUM_INT -> 8 [1639:71]
19159 | | | `--RPAREN -> ) [1639:72]
19160 | | |--COMMA -> , [1639:73]
19161 | | |--EXPR -> EXPR [1640:22]
19162 | | | `--PLUS -> + [1640:22]
19163 | | | |--STRING_LITERAL -> "41:11: " [1640:12]
19164 | | | `--METHOD_CALL -> ( [1640:39]
19165 | | | |--IDENT -> getCheckMessage [1640:24]
19166 | | | |--ELIST -> ELIST [1640:40]
19167 | | | | |--EXPR -> EXPR [1640:40]
19168 | | | | | `--IDENT -> MSG_ERROR [1640:40]
19169 | | | | |--COMMA -> , [1640:49]
19170 | | | | |--EXPR -> EXPR [1640:51]
19171 | | | | | `--STRING_LITERAL -> "while" [1640:51]
19172 | | | | |--COMMA -> , [1640:58]
19173 | | | | |--EXPR -> EXPR [1640:60]
19174 | | | | | `--NUM_INT -> 10 [1640:60]
19175 | | | | |--COMMA -> , [1640:62]
19176 | | | | `--EXPR -> EXPR [1640:64]
19177 | | | | `--NUM_INT -> 8 [1640:64]
19178 | | | `--RPAREN -> ) [1640:65]
19179 | | |--COMMA -> , [1640:66]
19180 | | |--EXPR -> EXPR [1641:22]
19181 | | | `--PLUS -> + [1641:22]
19182 | | | |--STRING_LITERAL -> "44:11: " [1641:12]
19183 | | | `--METHOD_CALL -> ( [1641:39]
19184 | | | |--IDENT -> getCheckMessage [1641:24]
19185 | | | |--ELIST -> ELIST [1641:40]
19186 | | | | |--EXPR -> EXPR [1641:40]
19187 | | | | | `--IDENT -> MSG_ERROR [1641:40]
19188 | | | | |--COMMA -> , [1641:49]
19189 | | | | |--EXPR -> EXPR [1641:51]
19190 | | | | | `--STRING_LITERAL -> "while rcurly" [1641:51]
19191 | | | | |--COMMA -> , [1641:65]
19192 | | | | |--EXPR -> EXPR [1641:67]
19193 | | | | | `--NUM_INT -> 10 [1641:67]
19194 | | | | |--COMMA -> , [1641:69]
19195 | | | | `--EXPR -> EXPR [1641:71]
19196 | | | | `--NUM_INT -> 8 [1641:71]
19197 | | | `--RPAREN -> ) [1641:72]
19198 | | |--COMMA -> , [1641:73]
19199 | | |--EXPR -> EXPR [1643:21]
19200 | | | `--PLUS -> + [1643:21]
19201 | | | |--STRING_LITERAL -> "46:7: " [1643:12]
19202 | | | `--METHOD_CALL -> ( [1643:38]
19203 | | | |--IDENT -> getCheckMessage [1643:23]
19204 | | | |--ELIST -> ELIST [1643:39]
19205 | | | | |--EXPR -> EXPR [1643:39]
19206 | | | | | `--IDENT -> MSG_ERROR [1643:39]
19207 | | | | |--COMMA -> , [1643:48]
19208 | | | | |--EXPR -> EXPR [1643:50]
19209 | | | | | `--STRING_LITERAL -> "while" [1643:50]
19210 | | | | |--COMMA -> , [1643:57]
19211 | | | | |--EXPR -> EXPR [1643:59]
19212 | | | | | `--NUM_INT -> 6 [1643:59]
19213 | | | | |--COMMA -> , [1643:60]
19214 | | | | `--EXPR -> EXPR [1643:62]
19215 | | | | `--NUM_INT -> 8 [1643:62]
19216 | | | `--RPAREN -> ) [1643:63]
19217 | | |--COMMA -> , [1643:64]
19218 | | |--EXPR -> EXPR [1644:22]
19219 | | | `--PLUS -> + [1644:22]
19220 | | | |--STRING_LITERAL -> "47:11: " [1644:12]
19221 | | | `--METHOD_CALL -> ( [1644:39]
19222 | | | |--IDENT -> getCheckMessage [1644:24]
19223 | | | |--ELIST -> ELIST [1644:40]
19224 | | | | |--EXPR -> EXPR [1644:40]
19225 | | | | | `--IDENT -> MSG_ERROR [1644:40]
19226 | | | | |--COMMA -> , [1644:49]
19227 | | | | |--EXPR -> EXPR [1644:51]
19228 | | | | | `--STRING_LITERAL -> "while lcurly" [1644:51]
19229 | | | | |--COMMA -> , [1644:65]
19230 | | | | |--EXPR -> EXPR [1644:67]
19231 | | | | | `--NUM_INT -> 10 [1644:67]
19232 | | | | |--COMMA -> , [1644:69]
19233 | | | | `--EXPR -> EXPR [1644:71]
19234 | | | | `--NUM_INT -> 8 [1644:71]
19235 | | | `--RPAREN -> ) [1644:72]
19236 | | |--COMMA -> , [1644:73]
19237 | | |--EXPR -> EXPR [1645:21]
19238 | | | `--PLUS -> + [1645:21]
19239 | | | |--STRING_LITERAL -> "50:7: " [1645:12]
19240 | | | `--METHOD_CALL -> ( [1645:38]
19241 | | | |--IDENT -> getCheckMessage [1645:23]
19242 | | | |--ELIST -> ELIST [1645:39]
19243 | | | | |--EXPR -> EXPR [1645:39]
19244 | | | | | `--IDENT -> MSG_ERROR [1645:39]
19245 | | | | |--COMMA -> , [1645:48]
19246 | | | | |--EXPR -> EXPR [1645:50]
19247 | | | | | `--STRING_LITERAL -> "while rcurly" [1645:50]
19248 | | | | |--COMMA -> , [1645:64]
19249 | | | | |--EXPR -> EXPR [1645:66]
19250 | | | | | `--NUM_INT -> 6 [1645:66]
19251 | | | | |--COMMA -> , [1645:67]
19252 | | | | `--EXPR -> EXPR [1645:69]
19253 | | | | `--NUM_INT -> 8 [1645:69]
19254 | | | `--RPAREN -> ) [1645:70]
19255 | | |--COMMA -> , [1645:71]
19256 | | |--EXPR -> EXPR [1646:22]
19257 | | | `--PLUS -> + [1646:22]
19258 | | | |--STRING_LITERAL -> "53:15: " [1646:12]
19259 | | | `--METHOD_CALL -> ( [1646:39]
19260 | | | |--IDENT -> getCheckMessage [1646:24]
19261 | | | |--ELIST -> ELIST [1646:40]
19262 | | | | |--EXPR -> EXPR [1646:40]
19263 | | | | | `--IDENT -> MSG_ERROR [1646:40]
19264 | | | | |--COMMA -> , [1646:49]
19265 | | | | |--EXPR -> EXPR [1646:51]
19266 | | | | | `--STRING_LITERAL -> "if" [1646:51]
19267 | | | | |--COMMA -> , [1646:55]
19268 | | | | |--EXPR -> EXPR [1646:57]
19269 | | | | | `--NUM_INT -> 14 [1646:57]
19270 | | | | |--COMMA -> , [1646:59]
19271 | | | | `--EXPR -> EXPR [1646:61]
19272 | | | | `--NUM_INT -> 12 [1646:61]
19273 | | | `--RPAREN -> ) [1646:63]
19274 | | |--COMMA -> , [1646:64]
19275 | | |--EXPR -> EXPR [1647:22]
19276 | | | `--PLUS -> + [1647:22]
19277 | | | |--STRING_LITERAL -> "54:19: " [1647:12]
19278 | | | `--METHOD_CALL -> ( [1647:39]
19279 | | | |--IDENT -> getCheckMessage [1647:24]
19280 | | | |--ELIST -> ELIST [1647:40]
19281 | | | | |--EXPR -> EXPR [1647:40]
19282 | | | | | `--IDENT -> MSG_CHILD_ERROR [1647:40]
19283 | | | | |--COMMA -> , [1647:55]
19284 | | | | |--EXPR -> EXPR [1647:57]
19285 | | | | | `--STRING_LITERAL -> "if" [1647:57]
19286 | | | | |--COMMA -> , [1647:61]
19287 | | | | |--EXPR -> EXPR [1647:63]
19288 | | | | | `--NUM_INT -> 18 [1647:63]
19289 | | | | |--COMMA -> , [1647:65]
19290 | | | | `--EXPR -> EXPR [1647:67]
19291 | | | | `--NUM_INT -> 16 [1647:67]
19292 | | | `--RPAREN -> ) [1647:69]
19293 | | |--COMMA -> , [1647:70]
19294 | | |--EXPR -> EXPR [1648:22]
19295 | | | `--PLUS -> + [1648:22]
19296 | | | |--STRING_LITERAL -> "55:15: " [1648:12]
19297 | | | `--METHOD_CALL -> ( [1648:39]
19298 | | | |--IDENT -> getCheckMessage [1648:24]
19299 | | | |--ELIST -> ELIST [1648:40]
19300 | | | | |--EXPR -> EXPR [1648:40]
19301 | | | | | `--IDENT -> MSG_ERROR [1648:40]
19302 | | | | |--COMMA -> , [1648:49]
19303 | | | | |--EXPR -> EXPR [1648:51]
19304 | | | | | `--STRING_LITERAL -> "if rcurly" [1648:51]
19305 | | | | |--COMMA -> , [1648:62]
19306 | | | | |--EXPR -> EXPR [1648:64]
19307 | | | | | `--NUM_INT -> 14 [1648:64]
19308 | | | | |--COMMA -> , [1648:66]
19309 | | | | `--EXPR -> EXPR [1648:68]
19310 | | | | `--NUM_INT -> 12 [1648:68]
19311 | | | `--RPAREN -> ) [1648:70]
19312 | | |--COMMA -> , [1648:71]
19313 | | |--EXPR -> EXPR [1649:22]
19314 | | | `--PLUS -> + [1649:22]
19315 | | | |--STRING_LITERAL -> "56:15: " [1649:12]
19316 | | | `--METHOD_CALL -> ( [1649:39]
19317 | | | |--IDENT -> getCheckMessage [1649:24]
19318 | | | |--ELIST -> ELIST [1649:40]
19319 | | | | |--EXPR -> EXPR [1649:40]
19320 | | | | | `--IDENT -> MSG_CHILD_ERROR [1649:40]
19321 | | | | |--COMMA -> , [1649:55]
19322 | | | | |--EXPR -> EXPR [1649:57]
19323 | | | | | `--STRING_LITERAL -> "while" [1649:57]
19324 | | | | |--COMMA -> , [1649:64]
19325 | | | | |--EXPR -> EXPR [1649:66]
19326 | | | | | `--NUM_INT -> 14 [1649:66]
19327 | | | | |--COMMA -> , [1649:68]
19328 | | | | `--EXPR -> EXPR [1649:70]
19329 | | | | `--NUM_INT -> 12 [1649:70]
19330 | | | `--RPAREN -> ) [1649:72]
19331 | | |--COMMA -> , [1649:73]
19332 | | |--EXPR -> EXPR [1650:22]
19333 | | | `--PLUS -> + [1650:22]
19334 | | | |--STRING_LITERAL -> "57:11: " [1650:12]
19335 | | | `--METHOD_CALL -> ( [1650:39]
19336 | | | |--IDENT -> getCheckMessage [1650:24]
19337 | | | |--ELIST -> ELIST [1650:40]
19338 | | | | |--EXPR -> EXPR [1650:40]
19339 | | | | | `--IDENT -> MSG_ERROR [1650:40]
19340 | | | | |--COMMA -> , [1650:49]
19341 | | | | |--EXPR -> EXPR [1650:51]
19342 | | | | | `--STRING_LITERAL -> "while rcurly" [1650:51]
19343 | | | | |--COMMA -> , [1650:65]
19344 | | | | |--EXPR -> EXPR [1650:67]
19345 | | | | | `--NUM_INT -> 10 [1650:67]
19346 | | | | |--COMMA -> , [1650:69]
19347 | | | | `--EXPR -> EXPR [1650:71]
19348 | | | | `--NUM_INT -> 8 [1650:71]
19349 | | | `--RPAREN -> ) [1650:72]
19350 | | |--COMMA -> , [1650:73]
19351 | | |--EXPR -> EXPR [1652:22]
19352 | | | `--PLUS -> + [1652:22]
19353 | | | |--STRING_LITERAL -> "60:11: " [1652:12]
19354 | | | `--METHOD_CALL -> ( [1652:39]
19355 | | | |--IDENT -> getCheckMessage [1652:24]
19356 | | | |--ELIST -> ELIST [1652:40]
19357 | | | | |--EXPR -> EXPR [1652:40]
19358 | | | | | `--IDENT -> MSG_CHILD_ERROR [1652:40]
19359 | | | | |--COMMA -> , [1652:55]
19360 | | | | |--EXPR -> EXPR [1652:57]
19361 | | | | | `--STRING_LITERAL -> "while" [1652:57]
19362 | | | | |--COMMA -> , [1652:64]
19363 | | | | |--EXPR -> EXPR [1652:66]
19364 | | | | | `--NUM_INT -> 10 [1652:66]
19365 | | | | |--COMMA -> , [1652:68]
19366 | | | | `--EXPR -> EXPR [1652:70]
19367 | | | | `--NUM_INT -> 12 [1652:70]
19368 | | | `--RPAREN -> ) [1652:72]
19369 | | |--COMMA -> , [1652:73]
19370 | | |--EXPR -> EXPR [1653:22]
19371 | | | `--PLUS -> + [1653:22]
19372 | | | |--STRING_LITERAL -> "66:11: " [1653:12]
19373 | | | `--METHOD_CALL -> ( [1653:39]
19374 | | | |--IDENT -> getCheckMessage [1653:24]
19375 | | | |--ELIST -> ELIST [1653:40]
19376 | | | | |--EXPR -> EXPR [1653:40]
19377 | | | | | `--IDENT -> MSG_CHILD_ERROR [1653:40]
19378 | | | | |--COMMA -> , [1653:55]
19379 | | | | |--EXPR -> EXPR [1653:57]
19380 | | | | | `--STRING_LITERAL -> "while" [1653:57]
19381 | | | | |--COMMA -> , [1653:64]
19382 | | | | |--EXPR -> EXPR [1653:66]
19383 | | | | | `--NUM_INT -> 10 [1653:66]
19384 | | | | |--COMMA -> , [1653:68]
19385 | | | | `--EXPR -> EXPR [1653:70]
19386 | | | | `--NUM_INT -> 12 [1653:70]
19387 | | | `--RPAREN -> ) [1653:72]
19388 | | |--COMMA -> , [1653:73]
19389 | | |--EXPR -> EXPR [1654:22]
19390 | | | `--PLUS -> + [1654:22]
19391 | | | |--STRING_LITERAL -> "71:11: " [1654:12]
19392 | | | `--METHOD_CALL -> ( [1654:39]
19393 | | | |--IDENT -> getCheckMessage [1654:24]
19394 | | | |--ELIST -> ELIST [1654:40]
19395 | | | | |--EXPR -> EXPR [1654:40]
19396 | | | | | `--IDENT -> MSG_CHILD_ERROR [1654:40]
19397 | | | | |--COMMA -> , [1654:55]
19398 | | | | |--EXPR -> EXPR [1654:57]
19399 | | | | | `--STRING_LITERAL -> "while" [1654:57]
19400 | | | | |--COMMA -> , [1654:64]
19401 | | | | |--EXPR -> EXPR [1654:66]
19402 | | | | | `--NUM_INT -> 10 [1654:66]
19403 | | | | |--COMMA -> , [1654:68]
19404 | | | | `--EXPR -> EXPR [1654:70]
19405 | | | | `--NUM_INT -> 12 [1654:70]
19406 | | | `--RPAREN -> ) [1654:72]
19407 | | |--COMMA -> , [1654:73]
19408 | | |--EXPR -> EXPR [1655:21]
19409 | | | `--PLUS -> + [1655:21]
19410 | | | |--STRING_LITERAL -> "78:6: " [1655:12]
19411 | | | `--METHOD_CALL -> ( [1655:38]
19412 | | | |--IDENT -> getCheckMessage [1655:23]
19413 | | | |--ELIST -> ELIST [1655:39]
19414 | | | | |--EXPR -> EXPR [1655:39]
19415 | | | | | `--IDENT -> MSG_ERROR [1655:39]
19416 | | | | |--COMMA -> , [1655:48]
19417 | | | | |--EXPR -> EXPR [1655:50]
19418 | | | | | `--STRING_LITERAL -> "while rparen" [1655:50]
19419 | | | | |--COMMA -> , [1655:64]
19420 | | | | |--EXPR -> EXPR [1655:66]
19421 | | | | | `--NUM_INT -> 5 [1655:66]
19422 | | | | |--COMMA -> , [1655:67]
19423 | | | | `--EXPR -> EXPR [1655:69]
19424 | | | | `--NUM_INT -> 8 [1655:69]
19425 | | | `--RPAREN -> ) [1655:70]
19426 | | |--COMMA -> , [1655:71]
19427 | | |--EXPR -> EXPR [1656:22]
19428 | | | `--PLUS -> + [1656:22]
19429 | | | |--STRING_LITERAL -> "85:11: " [1656:12]
19430 | | | `--METHOD_CALL -> ( [1656:39]
19431 | | | |--IDENT -> getCheckMessage [1656:24]
19432 | | | |--ELIST -> ELIST [1656:40]
19433 | | | | |--EXPR -> EXPR [1656:40]
19434 | | | | | `--IDENT -> MSG_ERROR [1656:40]
19435 | | | | |--COMMA -> , [1656:49]
19436 | | | | |--EXPR -> EXPR [1656:51]
19437 | | | | | `--STRING_LITERAL -> "while rparen" [1656:51]
19438 | | | | |--COMMA -> , [1656:65]
19439 | | | | |--EXPR -> EXPR [1656:67]
19440 | | | | | `--NUM_INT -> 10 [1656:67]
19441 | | | | |--COMMA -> , [1656:69]
19442 | | | | `--EXPR -> EXPR [1656:71]
19443 | | | | `--NUM_INT -> 8 [1656:71]
19444 | | | `--RPAREN -> ) [1656:72]
19445 | | |--COMMA -> , [1656:73]
19446 | | |--EXPR -> EXPR [1657:22]
19447 | | | `--PLUS -> + [1657:22]
19448 | | | |--STRING_LITERAL -> "92:11: " [1657:12]
19449 | | | `--METHOD_CALL -> ( [1657:39]
19450 | | | |--IDENT -> getCheckMessage [1657:24]
19451 | | | |--ELIST -> ELIST [1657:40]
19452 | | | | |--EXPR -> EXPR [1657:40]
19453 | | | | | `--IDENT -> MSG_ERROR [1657:40]
19454 | | | | |--COMMA -> , [1657:49]
19455 | | | | |--EXPR -> EXPR [1657:51]
19456 | | | | | `--STRING_LITERAL -> "while rparen" [1657:51]
19457 | | | | |--COMMA -> , [1657:65]
19458 | | | | |--EXPR -> EXPR [1657:67]
19459 | | | | | `--NUM_INT -> 10 [1657:67]
19460 | | | | |--COMMA -> , [1657:69]
19461 | | | | `--EXPR -> EXPR [1657:71]
19462 | | | | `--NUM_INT -> 8 [1657:71]
19463 | | | `--RPAREN -> ) [1657:72]
19464 | | |--COMMA -> , [1657:73]
19465 | | |--EXPR -> EXPR [1658:21]
19466 | | | `--PLUS -> + [1658:21]
19467 | | | |--STRING_LITERAL -> "99:9: " [1658:12]
19468 | | | `--METHOD_CALL -> ( [1658:38]
19469 | | | |--IDENT -> getCheckMessage [1658:23]
19470 | | | |--ELIST -> ELIST [1658:39]
19471 | | | | |--EXPR -> EXPR [1658:39]
19472 | | | | | `--IDENT -> MSG_CHILD_ERROR [1658:39]
19473 | | | | |--COMMA -> , [1658:54]
19474 | | | | |--EXPR -> EXPR [1658:56]
19475 | | | | | `--STRING_LITERAL -> "while" [1658:56]
19476 | | | | |--COMMA -> , [1658:63]
19477 | | | | |--EXPR -> EXPR [1658:65]
19478 | | | | | `--NUM_INT -> 8 [1658:65]
19479 | | | | |--COMMA -> , [1658:66]
19480 | | | | `--EXPR -> EXPR [1658:68]
19481 | | | | `--NUM_INT -> 12 [1658:68]
19482 | | | `--RPAREN -> ) [1658:70]
19483 | | |--COMMA -> , [1658:71]
19484 | | `--RCURLY -> } [1659:8]
19485 | |--SEMI -> ; [1659:9]
19486 | |--EXPR -> EXPR [1660:19]
19487 | | `--METHOD_CALL -> ( [1660:19]
19488 | | |--IDENT -> verifyWarns [1660:8]
19489 | | |--ELIST -> ELIST [1660:20]
19490 | | | |--EXPR -> EXPR [1660:20]
19491 | | | | `--IDENT -> checkConfig [1660:20]
19492 | | | |--COMMA -> , [1660:31]
19493 | | | |--EXPR -> EXPR [1660:33]
19494 | | | | `--IDENT -> fileName [1660:33]
19495 | | | |--COMMA -> , [1660:41]
19496 | | | `--EXPR -> EXPR [1660:43]
19497 | | | `--IDENT -> expected [1660:43]
19498 | | `--RPAREN -> ) [1660:51]
19499 | |--SEMI -> ; [1660:52]
19500 | `--RCURLY -> } [1661:4]
19501 |--METHOD_DEF -> METHOD_DEF [1663:4]
19502 | |--MODIFIERS -> MODIFIERS [1663:4]
19503 | | |--ANNOTATION -> ANNOTATION [1663:4]
19504 | | | |--AT -> @ [1663:4]
19505 | | | `--IDENT -> Test [1663:5]
19506 | | `--LITERAL_PUBLIC -> public [1664:4]
19507 | |--TYPE -> TYPE [1664:11]
19508 | | `--LITERAL_VOID -> void [1664:11]
19509 | |--IDENT -> testInvalidInvalidAnonymousClass [1664:16]
19510 | |--LPAREN -> ( [1664:48]
19511 | |--PARAMETERS -> PARAMETERS [1664:49]
19512 | |--RPAREN -> ) [1664:49]
19513 | |--LITERAL_THROWS -> throws [1664:51]
19514 | | `--IDENT -> Exception [1664:58]
19515 | `--SLIST -> { [1664:68]
19516 | |--VARIABLE_DEF -> VARIABLE_DEF [1665:8]
19517 | | |--MODIFIERS -> MODIFIERS [1665:8]
19518 | | | `--FINAL -> final [1665:8]
19519 | | |--TYPE -> TYPE [1665:14]
19520 | | | `--IDENT -> DefaultConfiguration [1665:14]
19521 | | |--IDENT -> checkConfig [1665:35]
19522 | | `--ASSIGN -> = [1665:47]
19523 | | `--EXPR -> EXPR [1665:67]
19524 | | `--METHOD_CALL -> ( [1665:67]
19525 | | |--IDENT -> createModuleConfig [1665:49]
19526 | | |--ELIST -> ELIST [1665:84]
19527 | | | `--EXPR -> EXPR [1665:84]
19528 | | | `--DOT -> . [1665:84]
19529 | | | |--IDENT -> IndentationCheck [1665:68]
19530 | | | `--LITERAL_CLASS -> class [1665:85]
19531 | | `--RPAREN -> ) [1665:90]
19532 | |--SEMI -> ; [1665:91]
19533 | |--EXPR -> EXPR [1667:32]
19534 | | `--METHOD_CALL -> ( [1667:32]
19535 | | |--DOT -> . [1667:19]
19536 | | | |--IDENT -> checkConfig [1667:8]
19537 | | | `--IDENT -> addAttribute [1667:20]
19538 | | |--ELIST -> ELIST [1667:33]
19539 | | | |--EXPR -> EXPR [1667:33]
19540 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1667:33]
19541 | | | |--COMMA -> , [1667:50]
19542 | | | `--EXPR -> EXPR [1667:52]
19543 | | | `--STRING_LITERAL -> "4" [1667:52]
19544 | | `--RPAREN -> ) [1667:55]
19545 | |--SEMI -> ; [1667:56]
19546 | |--EXPR -> EXPR [1668:32]
19547 | | `--METHOD_CALL -> ( [1668:32]
19548 | | |--DOT -> . [1668:19]
19549 | | | |--IDENT -> checkConfig [1668:8]
19550 | | | `--IDENT -> addAttribute [1668:20]
19551 | | |--ELIST -> ELIST [1668:33]
19552 | | | |--EXPR -> EXPR [1668:33]
19553 | | | | `--STRING_LITERAL -> "basicOffset" [1668:33]
19554 | | | |--COMMA -> , [1668:46]
19555 | | | `--EXPR -> EXPR [1668:48]
19556 | | | `--STRING_LITERAL -> "4" [1668:48]
19557 | | `--RPAREN -> ) [1668:51]
19558 | |--SEMI -> ; [1668:52]
19559 | |--EXPR -> EXPR [1669:32]
19560 | | `--METHOD_CALL -> ( [1669:32]
19561 | | |--DOT -> . [1669:19]
19562 | | | |--IDENT -> checkConfig [1669:8]
19563 | | | `--IDENT -> addAttribute [1669:20]
19564 | | |--ELIST -> ELIST [1669:33]
19565 | | | |--EXPR -> EXPR [1669:33]
19566 | | | | `--STRING_LITERAL -> "braceAdjustment" [1669:33]
19567 | | | |--COMMA -> , [1669:50]
19568 | | | `--EXPR -> EXPR [1669:52]
19569 | | | `--STRING_LITERAL -> "0" [1669:52]
19570 | | `--RPAREN -> ) [1669:55]
19571 | |--SEMI -> ; [1669:56]
19572 | |--EXPR -> EXPR [1670:32]
19573 | | `--METHOD_CALL -> ( [1670:32]
19574 | | |--DOT -> . [1670:19]
19575 | | | |--IDENT -> checkConfig [1670:8]
19576 | | | `--IDENT -> addAttribute [1670:20]
19577 | | |--ELIST -> ELIST [1670:33]
19578 | | | |--EXPR -> EXPR [1670:33]
19579 | | | | `--STRING_LITERAL -> "caseIndent" [1670:33]
19580 | | | |--COMMA -> , [1670:45]
19581 | | | `--EXPR -> EXPR [1670:47]
19582 | | | `--STRING_LITERAL -> "4" [1670:47]
19583 | | `--RPAREN -> ) [1670:50]
19584 | |--SEMI -> ; [1670:51]
19585 | |--EXPR -> EXPR [1671:32]
19586 | | `--METHOD_CALL -> ( [1671:32]
19587 | | |--DOT -> . [1671:19]
19588 | | | |--IDENT -> checkConfig [1671:8]
19589 | | | `--IDENT -> addAttribute [1671:20]
19590 | | |--ELIST -> ELIST [1671:33]
19591 | | | |--EXPR -> EXPR [1671:33]
19592 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1671:33]
19593 | | | |--COMMA -> , [1671:55]
19594 | | | `--EXPR -> EXPR [1671:57]
19595 | | | `--STRING_LITERAL -> "false" [1671:57]
19596 | | `--RPAREN -> ) [1671:64]
19597 | |--SEMI -> ; [1671:65]
19598 | |--EXPR -> EXPR [1672:32]
19599 | | `--METHOD_CALL -> ( [1672:32]
19600 | | |--DOT -> . [1672:19]
19601 | | | |--IDENT -> checkConfig [1672:8]
19602 | | | `--IDENT -> addAttribute [1672:20]
19603 | | |--ELIST -> ELIST [1672:33]
19604 | | | |--EXPR -> EXPR [1672:33]
19605 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1672:33]
19606 | | | |--COMMA -> , [1672:58]
19607 | | | `--EXPR -> EXPR [1672:60]
19608 | | | `--STRING_LITERAL -> "4" [1672:60]
19609 | | `--RPAREN -> ) [1672:63]
19610 | |--SEMI -> ; [1672:64]
19611 | |--EXPR -> EXPR [1673:32]
19612 | | `--METHOD_CALL -> ( [1673:32]
19613 | | |--DOT -> . [1673:19]
19614 | | | |--IDENT -> checkConfig [1673:8]
19615 | | | `--IDENT -> addAttribute [1673:20]
19616 | | |--ELIST -> ELIST [1673:33]
19617 | | | |--EXPR -> EXPR [1673:33]
19618 | | | | `--STRING_LITERAL -> "tabWidth" [1673:33]
19619 | | | |--COMMA -> , [1673:43]
19620 | | | `--EXPR -> EXPR [1673:45]
19621 | | | `--STRING_LITERAL -> "4" [1673:45]
19622 | | `--RPAREN -> ) [1673:48]
19623 | |--SEMI -> ; [1673:49]
19624 | |--EXPR -> EXPR [1674:32]
19625 | | `--METHOD_CALL -> ( [1674:32]
19626 | | |--DOT -> . [1674:19]
19627 | | | |--IDENT -> checkConfig [1674:8]
19628 | | | `--IDENT -> addAttribute [1674:20]
19629 | | |--ELIST -> ELIST [1674:33]
19630 | | | |--EXPR -> EXPR [1674:33]
19631 | | | | `--STRING_LITERAL -> "throwsIndent" [1674:33]
19632 | | | |--COMMA -> , [1674:47]
19633 | | | `--EXPR -> EXPR [1674:49]
19634 | | | `--STRING_LITERAL -> "4" [1674:49]
19635 | | `--RPAREN -> ) [1674:52]
19636 | |--SEMI -> ; [1674:53]
19637 | |--VARIABLE_DEF -> VARIABLE_DEF [1675:8]
19638 | | |--MODIFIERS -> MODIFIERS [1675:8]
19639 | | | `--FINAL -> final [1675:8]
19640 | | |--TYPE -> TYPE [1675:14]
19641 | | | `--IDENT -> String [1675:14]
19642 | | |--IDENT -> fileName [1675:21]
19643 | | `--ASSIGN -> = [1675:30]
19644 | | `--EXPR -> EXPR [1675:39]
19645 | | `--METHOD_CALL -> ( [1675:39]
19646 | | |--IDENT -> getPath [1675:32]
19647 | | |--ELIST -> ELIST [1675:40]
19648 | | | `--EXPR -> EXPR [1675:40]
19649 | | | `--STRING_LITERAL -> "InputIndentationInvalidAnonymousClassIndent.java" [1675:40]
19650 | | `--RPAREN -> ) [1675:90]
19651 | |--SEMI -> ; [1675:91]
19652 | |--VARIABLE_DEF -> VARIABLE_DEF [1676:8]
19653 | | |--MODIFIERS -> MODIFIERS [1676:8]
19654 | | | `--FINAL -> final [1676:8]
19655 | | |--TYPE -> TYPE [1676:20]
19656 | | | `--ARRAY_DECLARATOR -> [ [1676:20]
19657 | | | |--IDENT -> String [1676:14]
19658 | | | `--RBRACK -> ] [1676:21]
19659 | | |--IDENT -> expected [1676:23]
19660 | | `--ASSIGN -> = [1676:32]
19661 | | `--EXPR -> EXPR [1676:44]
19662 | | `--DOT -> . [1676:44]
19663 | | |--IDENT -> CommonUtil [1676:34]
19664 | | `--IDENT -> EMPTY_STRING_ARRAY [1676:45]
19665 | |--SEMI -> ; [1676:63]
19666 | |--EXPR -> EXPR [1677:19]
19667 | | `--METHOD_CALL -> ( [1677:19]
19668 | | |--IDENT -> verifyWarns [1677:8]
19669 | | |--ELIST -> ELIST [1677:20]
19670 | | | |--EXPR -> EXPR [1677:20]
19671 | | | | `--IDENT -> checkConfig [1677:20]
19672 | | | |--COMMA -> , [1677:31]
19673 | | | |--EXPR -> EXPR [1677:33]
19674 | | | | `--IDENT -> fileName [1677:33]
19675 | | | |--COMMA -> , [1677:41]
19676 | | | `--EXPR -> EXPR [1677:43]
19677 | | | `--IDENT -> expected [1677:43]
19678 | | `--RPAREN -> ) [1677:51]
19679 | |--SEMI -> ; [1677:52]
19680 | `--RCURLY -> } [1678:4]
19681 |--METHOD_DEF -> METHOD_DEF [1680:4]
19682 | |--MODIFIERS -> MODIFIERS [1680:4]
19683 | | |--ANNOTATION -> ANNOTATION [1680:4]
19684 | | | |--AT -> @ [1680:4]
19685 | | | `--IDENT -> Test [1680:5]
19686 | | `--LITERAL_PUBLIC -> public [1681:4]
19687 | |--TYPE -> TYPE [1681:11]
19688 | | `--LITERAL_VOID -> void [1681:11]
19689 | |--IDENT -> testInvalidForWithChecker [1681:16]
19690 | |--LPAREN -> ( [1681:41]
19691 | |--PARAMETERS -> PARAMETERS [1681:42]
19692 | |--RPAREN -> ) [1681:42]
19693 | |--LITERAL_THROWS -> throws [1682:12]
19694 | | `--IDENT -> Exception [1682:19]
19695 | `--SLIST -> { [1682:29]
19696 | |--VARIABLE_DEF -> VARIABLE_DEF [1683:8]
19697 | | |--MODIFIERS -> MODIFIERS [1683:8]
19698 | | | `--FINAL -> final [1683:8]
19699 | | |--TYPE -> TYPE [1683:14]
19700 | | | `--IDENT -> DefaultConfiguration [1683:14]
19701 | | |--IDENT -> checkConfig [1683:35]
19702 | | `--ASSIGN -> = [1683:47]
19703 | | `--EXPR -> EXPR [1683:67]
19704 | | `--METHOD_CALL -> ( [1683:67]
19705 | | |--IDENT -> createModuleConfig [1683:49]
19706 | | |--ELIST -> ELIST [1683:84]
19707 | | | `--EXPR -> EXPR [1683:84]
19708 | | | `--DOT -> . [1683:84]
19709 | | | |--IDENT -> IndentationCheck [1683:68]
19710 | | | `--LITERAL_CLASS -> class [1683:85]
19711 | | `--RPAREN -> ) [1683:90]
19712 | |--SEMI -> ; [1683:91]
19713 | |--EXPR -> EXPR [1685:32]
19714 | | `--METHOD_CALL -> ( [1685:32]
19715 | | |--DOT -> . [1685:19]
19716 | | | |--IDENT -> checkConfig [1685:8]
19717 | | | `--IDENT -> addAttribute [1685:20]
19718 | | |--ELIST -> ELIST [1685:33]
19719 | | | |--EXPR -> EXPR [1685:33]
19720 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1685:33]
19721 | | | |--COMMA -> , [1685:50]
19722 | | | `--EXPR -> EXPR [1685:52]
19723 | | | `--STRING_LITERAL -> "4" [1685:52]
19724 | | `--RPAREN -> ) [1685:55]
19725 | |--SEMI -> ; [1685:56]
19726 | |--EXPR -> EXPR [1686:32]
19727 | | `--METHOD_CALL -> ( [1686:32]
19728 | | |--DOT -> . [1686:19]
19729 | | | |--IDENT -> checkConfig [1686:8]
19730 | | | `--IDENT -> addAttribute [1686:20]
19731 | | |--ELIST -> ELIST [1686:33]
19732 | | | |--EXPR -> EXPR [1686:33]
19733 | | | | `--STRING_LITERAL -> "basicOffset" [1686:33]
19734 | | | |--COMMA -> , [1686:46]
19735 | | | `--EXPR -> EXPR [1686:48]
19736 | | | `--STRING_LITERAL -> "4" [1686:48]
19737 | | `--RPAREN -> ) [1686:51]
19738 | |--SEMI -> ; [1686:52]
19739 | |--EXPR -> EXPR [1687:32]
19740 | | `--METHOD_CALL -> ( [1687:32]
19741 | | |--DOT -> . [1687:19]
19742 | | | |--IDENT -> checkConfig [1687:8]
19743 | | | `--IDENT -> addAttribute [1687:20]
19744 | | |--ELIST -> ELIST [1687:33]
19745 | | | |--EXPR -> EXPR [1687:33]
19746 | | | | `--STRING_LITERAL -> "braceAdjustment" [1687:33]
19747 | | | |--COMMA -> , [1687:50]
19748 | | | `--EXPR -> EXPR [1687:52]
19749 | | | `--STRING_LITERAL -> "0" [1687:52]
19750 | | `--RPAREN -> ) [1687:55]
19751 | |--SEMI -> ; [1687:56]
19752 | |--EXPR -> EXPR [1688:32]
19753 | | `--METHOD_CALL -> ( [1688:32]
19754 | | |--DOT -> . [1688:19]
19755 | | | |--IDENT -> checkConfig [1688:8]
19756 | | | `--IDENT -> addAttribute [1688:20]
19757 | | |--ELIST -> ELIST [1688:33]
19758 | | | |--EXPR -> EXPR [1688:33]
19759 | | | | `--STRING_LITERAL -> "caseIndent" [1688:33]
19760 | | | |--COMMA -> , [1688:45]
19761 | | | `--EXPR -> EXPR [1688:47]
19762 | | | `--STRING_LITERAL -> "4" [1688:47]
19763 | | `--RPAREN -> ) [1688:50]
19764 | |--SEMI -> ; [1688:51]
19765 | |--EXPR -> EXPR [1689:32]
19766 | | `--METHOD_CALL -> ( [1689:32]
19767 | | |--DOT -> . [1689:19]
19768 | | | |--IDENT -> checkConfig [1689:8]
19769 | | | `--IDENT -> addAttribute [1689:20]
19770 | | |--ELIST -> ELIST [1689:33]
19771 | | | |--EXPR -> EXPR [1689:33]
19772 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1689:33]
19773 | | | |--COMMA -> , [1689:55]
19774 | | | `--EXPR -> EXPR [1689:57]
19775 | | | `--STRING_LITERAL -> "false" [1689:57]
19776 | | `--RPAREN -> ) [1689:64]
19777 | |--SEMI -> ; [1689:65]
19778 | |--EXPR -> EXPR [1690:32]
19779 | | `--METHOD_CALL -> ( [1690:32]
19780 | | |--DOT -> . [1690:19]
19781 | | | |--IDENT -> checkConfig [1690:8]
19782 | | | `--IDENT -> addAttribute [1690:20]
19783 | | |--ELIST -> ELIST [1690:33]
19784 | | | |--EXPR -> EXPR [1690:33]
19785 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1690:33]
19786 | | | |--COMMA -> , [1690:58]
19787 | | | `--EXPR -> EXPR [1690:60]
19788 | | | `--STRING_LITERAL -> "4" [1690:60]
19789 | | `--RPAREN -> ) [1690:63]
19790 | |--SEMI -> ; [1690:64]
19791 | |--EXPR -> EXPR [1691:32]
19792 | | `--METHOD_CALL -> ( [1691:32]
19793 | | |--DOT -> . [1691:19]
19794 | | | |--IDENT -> checkConfig [1691:8]
19795 | | | `--IDENT -> addAttribute [1691:20]
19796 | | |--ELIST -> ELIST [1691:33]
19797 | | | |--EXPR -> EXPR [1691:33]
19798 | | | | `--STRING_LITERAL -> "tabWidth" [1691:33]
19799 | | | |--COMMA -> , [1691:43]
19800 | | | `--EXPR -> EXPR [1691:45]
19801 | | | `--STRING_LITERAL -> "4" [1691:45]
19802 | | `--RPAREN -> ) [1691:48]
19803 | |--SEMI -> ; [1691:49]
19804 | |--EXPR -> EXPR [1692:32]
19805 | | `--METHOD_CALL -> ( [1692:32]
19806 | | |--DOT -> . [1692:19]
19807 | | | |--IDENT -> checkConfig [1692:8]
19808 | | | `--IDENT -> addAttribute [1692:20]
19809 | | |--ELIST -> ELIST [1692:33]
19810 | | | |--EXPR -> EXPR [1692:33]
19811 | | | | `--STRING_LITERAL -> "throwsIndent" [1692:33]
19812 | | | |--COMMA -> , [1692:47]
19813 | | | `--EXPR -> EXPR [1692:49]
19814 | | | `--STRING_LITERAL -> "4" [1692:49]
19815 | | `--RPAREN -> ) [1692:52]
19816 | |--SEMI -> ; [1692:53]
19817 | |--VARIABLE_DEF -> VARIABLE_DEF [1693:8]
19818 | | |--MODIFIERS -> MODIFIERS [1693:8]
19819 | | | `--FINAL -> final [1693:8]
19820 | | |--TYPE -> TYPE [1693:14]
19821 | | | `--IDENT -> String [1693:14]
19822 | | |--IDENT -> fileName [1693:21]
19823 | | `--ASSIGN -> = [1693:30]
19824 | | `--EXPR -> EXPR [1693:39]
19825 | | `--METHOD_CALL -> ( [1693:39]
19826 | | |--IDENT -> getPath [1693:32]
19827 | | |--ELIST -> ELIST [1693:40]
19828 | | | `--EXPR -> EXPR [1693:40]
19829 | | | `--STRING_LITERAL -> "InputIndentationInvalidForIndent.java" [1693:40]
19830 | | `--RPAREN -> ) [1693:79]
19831 | |--SEMI -> ; [1693:80]
19832 | |--VARIABLE_DEF -> VARIABLE_DEF [1694:8]
19833 | | |--MODIFIERS -> MODIFIERS [1694:8]
19834 | | | `--FINAL -> final [1694:8]
19835 | | |--TYPE -> TYPE [1694:20]
19836 | | | `--ARRAY_DECLARATOR -> [ [1694:20]
19837 | | | |--IDENT -> String [1694:14]
19838 | | | `--RBRACK -> ] [1694:21]
19839 | | |--IDENT -> expected [1694:23]
19840 | | `--ASSIGN -> = [1694:32]
19841 | | `--ARRAY_INIT -> { [1694:34]
19842 | | |--EXPR -> EXPR [1695:21]
19843 | | | `--PLUS -> + [1695:21]
19844 | | | |--STRING_LITERAL -> "26:7: " [1695:12]
19845 | | | `--METHOD_CALL -> ( [1695:38]
19846 | | | |--IDENT -> getCheckMessage [1695:23]
19847 | | | |--ELIST -> ELIST [1695:39]
19848 | | | | |--EXPR -> EXPR [1695:39]
19849 | | | | | `--IDENT -> MSG_ERROR [1695:39]
19850 | | | | |--COMMA -> , [1695:48]
19851 | | | | |--EXPR -> EXPR [1695:50]
19852 | | | | | `--STRING_LITERAL -> "for" [1695:50]
19853 | | | | |--COMMA -> , [1695:55]
19854 | | | | |--EXPR -> EXPR [1695:57]
19855 | | | | | `--NUM_INT -> 6 [1695:57]
19856 | | | | |--COMMA -> , [1695:58]
19857 | | | | `--EXPR -> EXPR [1695:60]
19858 | | | | `--NUM_INT -> 8 [1695:60]
19859 | | | `--RPAREN -> ) [1695:61]
19860 | | |--COMMA -> , [1695:62]
19861 | | |--EXPR -> EXPR [1696:22]
19862 | | | `--PLUS -> + [1696:22]
19863 | | | |--STRING_LITERAL -> "27:11: " [1696:12]
19864 | | | `--METHOD_CALL -> ( [1696:39]
19865 | | | |--IDENT -> getCheckMessage [1696:24]
19866 | | | |--ELIST -> ELIST [1696:40]
19867 | | | | |--EXPR -> EXPR [1696:40]
19868 | | | | | `--IDENT -> MSG_ERROR [1696:40]
19869 | | | | |--COMMA -> , [1696:49]
19870 | | | | |--EXPR -> EXPR [1696:51]
19871 | | | | | `--STRING_LITERAL -> "for rcurly" [1696:51]
19872 | | | | |--COMMA -> , [1696:63]
19873 | | | | |--EXPR -> EXPR [1696:65]
19874 | | | | | `--NUM_INT -> 10 [1696:65]
19875 | | | | |--COMMA -> , [1696:67]
19876 | | | | `--EXPR -> EXPR [1696:69]
19877 | | | | `--NUM_INT -> 8 [1696:69]
19878 | | | `--RPAREN -> ) [1696:70]
19879 | | |--COMMA -> , [1696:71]
19880 | | |--EXPR -> EXPR [1697:22]
19881 | | | `--PLUS -> + [1697:22]
19882 | | | |--STRING_LITERAL -> "29:10: " [1697:12]
19883 | | | `--METHOD_CALL -> ( [1697:39]
19884 | | | |--IDENT -> getCheckMessage [1697:24]
19885 | | | |--ELIST -> ELIST [1697:40]
19886 | | | | |--EXPR -> EXPR [1697:40]
19887 | | | | | `--IDENT -> MSG_ERROR [1697:40]
19888 | | | | |--COMMA -> , [1697:49]
19889 | | | | |--EXPR -> EXPR [1697:51]
19890 | | | | | `--STRING_LITERAL -> "for" [1697:51]
19891 | | | | |--COMMA -> , [1697:56]
19892 | | | | |--EXPR -> EXPR [1697:58]
19893 | | | | | `--NUM_INT -> 9 [1697:58]
19894 | | | | |--COMMA -> , [1697:59]
19895 | | | | `--EXPR -> EXPR [1697:61]
19896 | | | | `--NUM_INT -> 8 [1697:61]
19897 | | | `--RPAREN -> ) [1697:62]
19898 | | |--COMMA -> , [1697:63]
19899 | | |--EXPR -> EXPR [1698:21]
19900 | | | `--PLUS -> + [1698:21]
19901 | | | |--STRING_LITERAL -> "30:7: " [1698:12]
19902 | | | `--METHOD_CALL -> ( [1698:38]
19903 | | | |--IDENT -> getCheckMessage [1698:23]
19904 | | | |--ELIST -> ELIST [1698:39]
19905 | | | | |--EXPR -> EXPR [1698:39]
19906 | | | | | `--IDENT -> MSG_ERROR [1698:39]
19907 | | | | |--COMMA -> , [1698:48]
19908 | | | | |--EXPR -> EXPR [1698:50]
19909 | | | | | `--STRING_LITERAL -> "for lcurly" [1698:50]
19910 | | | | |--COMMA -> , [1698:62]
19911 | | | | |--EXPR -> EXPR [1698:64]
19912 | | | | | `--NUM_INT -> 6 [1698:64]
19913 | | | | |--COMMA -> , [1698:65]
19914 | | | | `--EXPR -> EXPR [1698:67]
19915 | | | | `--NUM_INT -> 8 [1698:67]
19916 | | | `--RPAREN -> ) [1698:68]
19917 | | |--COMMA -> , [1698:69]
19918 | | |--EXPR -> EXPR [1699:21]
19919 | | | `--PLUS -> + [1699:21]
19920 | | | |--STRING_LITERAL -> "31:7: " [1699:12]
19921 | | | `--METHOD_CALL -> ( [1699:38]
19922 | | | |--IDENT -> getCheckMessage [1699:23]
19923 | | | |--ELIST -> ELIST [1699:39]
19924 | | | | |--EXPR -> EXPR [1699:39]
19925 | | | | | `--IDENT -> MSG_ERROR [1699:39]
19926 | | | | |--COMMA -> , [1699:48]
19927 | | | | |--EXPR -> EXPR [1699:50]
19928 | | | | | `--STRING_LITERAL -> "for rcurly" [1699:50]
19929 | | | | |--COMMA -> , [1699:62]
19930 | | | | |--EXPR -> EXPR [1699:64]
19931 | | | | | `--NUM_INT -> 6 [1699:64]
19932 | | | | |--COMMA -> , [1699:65]
19933 | | | | `--EXPR -> EXPR [1699:67]
19934 | | | | `--NUM_INT -> 8 [1699:67]
19935 | | | `--RPAREN -> ) [1699:68]
19936 | | |--COMMA -> , [1699:69]
19937 | | |--EXPR -> EXPR [1700:22]
19938 | | | `--PLUS -> + [1700:22]
19939 | | | |--STRING_LITERAL -> "35:11: " [1700:12]
19940 | | | `--METHOD_CALL -> ( [1700:39]
19941 | | | |--IDENT -> getCheckMessage [1700:24]
19942 | | | |--ELIST -> ELIST [1700:40]
19943 | | | | |--EXPR -> EXPR [1700:40]
19944 | | | | | `--IDENT -> MSG_CHILD_ERROR [1700:40]
19945 | | | | |--COMMA -> , [1700:55]
19946 | | | | |--EXPR -> EXPR [1700:57]
19947 | | | | | `--STRING_LITERAL -> "for" [1700:57]
19948 | | | | |--COMMA -> , [1700:62]
19949 | | | | |--EXPR -> EXPR [1700:64]
19950 | | | | | `--NUM_INT -> 10 [1700:64]
19951 | | | | |--COMMA -> , [1700:66]
19952 | | | | `--EXPR -> EXPR [1700:68]
19953 | | | | `--NUM_INT -> 12 [1700:68]
19954 | | | `--RPAREN -> ) [1700:70]
19955 | | |--COMMA -> , [1700:71]
19956 | | |--EXPR -> EXPR [1702:22]
19957 | | | `--PLUS -> + [1702:22]
19958 | | | |--STRING_LITERAL -> "36:11: " [1702:12]
19959 | | | `--METHOD_CALL -> ( [1702:39]
19960 | | | |--IDENT -> getCheckMessage [1702:24]
19961 | | | |--ELIST -> ELIST [1702:40]
19962 | | | | |--EXPR -> EXPR [1702:40]
19963 | | | | | `--IDENT -> MSG_ERROR [1702:40]
19964 | | | | |--COMMA -> , [1702:49]
19965 | | | | |--EXPR -> EXPR [1702:51]
19966 | | | | | `--STRING_LITERAL -> "for rcurly" [1702:51]
19967 | | | | |--COMMA -> , [1702:63]
19968 | | | | |--EXPR -> EXPR [1702:65]
19969 | | | | | `--NUM_INT -> 10 [1702:65]
19970 | | | | |--COMMA -> , [1702:67]
19971 | | | | `--EXPR -> EXPR [1702:69]
19972 | | | | `--NUM_INT -> 8 [1702:69]
19973 | | | `--RPAREN -> ) [1702:70]
19974 | | |--COMMA -> , [1702:71]
19975 | | |--EXPR -> EXPR [1703:22]
19976 | | | `--PLUS -> + [1703:22]
19977 | | | |--STRING_LITERAL -> "39:11: " [1703:12]
19978 | | | `--METHOD_CALL -> ( [1703:39]
19979 | | | |--IDENT -> getCheckMessage [1703:24]
19980 | | | |--ELIST -> ELIST [1703:40]
19981 | | | | |--EXPR -> EXPR [1703:40]
19982 | | | | | `--IDENT -> MSG_ERROR [1703:40]
19983 | | | | |--COMMA -> , [1703:49]
19984 | | | | |--EXPR -> EXPR [1703:51]
19985 | | | | | `--STRING_LITERAL -> "for lcurly" [1703:51]
19986 | | | | |--COMMA -> , [1703:63]
19987 | | | | |--EXPR -> EXPR [1703:65]
19988 | | | | | `--NUM_INT -> 10 [1703:65]
19989 | | | | |--COMMA -> , [1703:67]
19990 | | | | `--EXPR -> EXPR [1703:69]
19991 | | | | `--NUM_INT -> 8 [1703:69]
19992 | | | `--RPAREN -> ) [1703:70]
19993 | | |--COMMA -> , [1703:71]
19994 | | |--EXPR -> EXPR [1704:22]
19995 | | | `--PLUS -> + [1704:22]
19996 | | | |--STRING_LITERAL -> "40:11: " [1704:12]
19997 | | | `--METHOD_CALL -> ( [1704:39]
19998 | | | |--IDENT -> getCheckMessage [1704:24]
19999 | | | |--ELIST -> ELIST [1704:40]
20000 | | | | |--EXPR -> EXPR [1704:40]
20001 | | | | | `--IDENT -> MSG_CHILD_ERROR [1704:40]
20002 | | | | |--COMMA -> , [1704:55]
20003 | | | | |--EXPR -> EXPR [1704:57]
20004 | | | | | `--STRING_LITERAL -> "for" [1704:57]
20005 | | | | |--COMMA -> , [1704:62]
20006 | | | | |--EXPR -> EXPR [1704:64]
20007 | | | | | `--NUM_INT -> 10 [1704:64]
20008 | | | | |--COMMA -> , [1704:66]
20009 | | | | `--EXPR -> EXPR [1704:68]
20010 | | | | `--NUM_INT -> 12 [1704:68]
20011 | | | `--RPAREN -> ) [1704:70]
20012 | | |--COMMA -> , [1704:71]
20013 | | |--EXPR -> EXPR [1705:22]
20014 | | | `--PLUS -> + [1705:22]
20015 | | | |--STRING_LITERAL -> "48:11: " [1705:12]
20016 | | | `--METHOD_CALL -> ( [1705:39]
20017 | | | |--IDENT -> getCheckMessage [1705:24]
20018 | | | |--ELIST -> ELIST [1705:40]
20019 | | | | |--EXPR -> EXPR [1705:40]
20020 | | | | | `--IDENT -> MSG_CHILD_ERROR [1705:40]
20021 | | | | |--COMMA -> , [1705:55]
20022 | | | | |--EXPR -> EXPR [1705:57]
20023 | | | | | `--STRING_LITERAL -> "for" [1705:57]
20024 | | | | |--COMMA -> , [1705:62]
20025 | | | | |--EXPR -> EXPR [1705:64]
20026 | | | | | `--NUM_INT -> 10 [1705:64]
20027 | | | | |--COMMA -> , [1705:66]
20028 | | | | `--EXPR -> EXPR [1705:68]
20029 | | | | `--NUM_INT -> 12 [1705:68]
20030 | | | `--RPAREN -> ) [1705:70]
20031 | | |--COMMA -> , [1705:71]
20032 | | |--EXPR -> EXPR [1706:21]
20033 | | | `--PLUS -> + [1706:21]
20034 | | | |--STRING_LITERAL -> "54:8: " [1706:12]
20035 | | | `--METHOD_CALL -> ( [1706:38]
20036 | | | |--IDENT -> getCheckMessage [1706:23]
20037 | | | |--ELIST -> ELIST [1706:39]
20038 | | | | |--EXPR -> EXPR [1706:39]
20039 | | | | | `--IDENT -> MSG_ERROR [1706:39]
20040 | | | | |--COMMA -> , [1706:48]
20041 | | | | |--EXPR -> EXPR [1706:50]
20042 | | | | | `--STRING_LITERAL -> "for" [1706:50]
20043 | | | | |--COMMA -> , [1706:55]
20044 | | | | |--EXPR -> EXPR [1706:57]
20045 | | | | | `--NUM_INT -> 7 [1706:57]
20046 | | | | |--COMMA -> , [1706:58]
20047 | | | | `--EXPR -> EXPR [1706:60]
20048 | | | | `--NUM_INT -> 8 [1706:60]
20049 | | | `--RPAREN -> ) [1706:61]
20050 | | |--COMMA -> , [1706:62]
20051 | | |--EXPR -> EXPR [1708:22]
20052 | | | `--PLUS -> + [1708:22]
20053 | | | |--STRING_LITERAL -> "55:11: " [1708:12]
20054 | | | `--METHOD_CALL -> ( [1708:39]
20055 | | | |--IDENT -> getCheckMessage [1708:24]
20056 | | | |--ELIST -> ELIST [1708:40]
20057 | | | | |--EXPR -> EXPR [1708:40]
20058 | | | | | `--IDENT -> MSG_CHILD_ERROR [1708:40]
20059 | | | | |--COMMA -> , [1708:55]
20060 | | | | |--EXPR -> EXPR [1708:57]
20061 | | | | | `--STRING_LITERAL -> "for" [1708:57]
20062 | | | | |--COMMA -> , [1708:62]
20063 | | | | |--EXPR -> EXPR [1708:64]
20064 | | | | | `--NUM_INT -> 10 [1708:64]
20065 | | | | |--COMMA -> , [1708:66]
20066 | | | | `--EXPR -> EXPR [1708:68]
20067 | | | | `--NUM_INT -> 12 [1708:68]
20068 | | | `--RPAREN -> ) [1708:70]
20069 | | |--COMMA -> , [1708:71]
20070 | | |--EXPR -> EXPR [1709:21]
20071 | | | `--PLUS -> + [1709:21]
20072 | | | |--STRING_LITERAL -> "64:8: " [1709:12]
20073 | | | `--METHOD_CALL -> ( [1709:38]
20074 | | | |--IDENT -> getCheckMessage [1709:23]
20075 | | | |--ELIST -> ELIST [1709:39]
20076 | | | | |--EXPR -> EXPR [1709:39]
20077 | | | | | `--IDENT -> MSG_CHILD_ERROR [1709:39]
20078 | | | | |--COMMA -> , [1709:54]
20079 | | | | |--EXPR -> EXPR [1709:56]
20080 | | | | | `--STRING_LITERAL -> "for" [1709:56]
20081 | | | | |--COMMA -> , [1709:61]
20082 | | | | |--EXPR -> EXPR [1709:63]
20083 | | | | | `--NUM_INT -> 7 [1709:63]
20084 | | | | |--COMMA -> , [1709:64]
20085 | | | | `--EXPR -> EXPR [1709:66]
20086 | | | | `--NUM_INT -> 12 [1709:66]
20087 | | | `--RPAREN -> ) [1709:68]
20088 | | |--COMMA -> , [1709:69]
20089 | | |--EXPR -> EXPR [1711:21]
20090 | | | `--PLUS -> + [1711:21]
20091 | | | |--STRING_LITERAL -> "69:7: " [1711:12]
20092 | | | `--METHOD_CALL -> ( [1711:38]
20093 | | | |--IDENT -> getCheckMessage [1711:23]
20094 | | | |--ELIST -> ELIST [1711:39]
20095 | | | | |--EXPR -> EXPR [1711:39]
20096 | | | | | `--IDENT -> MSG_ERROR [1711:39]
20097 | | | | |--COMMA -> , [1711:48]
20098 | | | | |--EXPR -> EXPR [1711:50]
20099 | | | | | `--STRING_LITERAL -> "for" [1711:50]
20100 | | | | |--COMMA -> , [1711:55]
20101 | | | | |--EXPR -> EXPR [1711:57]
20102 | | | | | `--NUM_INT -> 6 [1711:57]
20103 | | | | |--COMMA -> , [1711:58]
20104 | | | | `--EXPR -> EXPR [1711:60]
20105 | | | | `--NUM_INT -> 8 [1711:60]
20106 | | | `--RPAREN -> ) [1711:61]
20107 | | |--COMMA -> , [1711:62]
20108 | | |--EXPR -> EXPR [1712:22]
20109 | | | `--PLUS -> + [1712:22]
20110 | | | |--STRING_LITERAL -> "70:11: " [1712:12]
20111 | | | `--METHOD_CALL -> ( [1712:39]
20112 | | | |--IDENT -> getCheckMessage [1712:24]
20113 | | | |--ELIST -> ELIST [1712:40]
20114 | | | | |--EXPR -> EXPR [1712:40]
20115 | | | | | `--IDENT -> MSG_CHILD_ERROR [1712:40]
20116 | | | | |--COMMA -> , [1712:55]
20117 | | | | |--EXPR -> EXPR [1712:57]
20118 | | | | | `--STRING_LITERAL -> "for" [1712:57]
20119 | | | | |--COMMA -> , [1712:62]
20120 | | | | |--EXPR -> EXPR [1712:64]
20121 | | | | | `--NUM_INT -> 10 [1712:64]
20122 | | | | |--COMMA -> , [1712:66]
20123 | | | | `--EXPR -> EXPR [1712:68]
20124 | | | | `--NUM_INT -> 12 [1712:68]
20125 | | | `--RPAREN -> ) [1712:70]
20126 | | |--COMMA -> , [1712:71]
20127 | | |--EXPR -> EXPR [1713:22]
20128 | | | `--PLUS -> + [1713:22]
20129 | | | |--STRING_LITERAL -> "71:15: " [1713:12]
20130 | | | `--METHOD_CALL -> ( [1713:39]
20131 | | | |--IDENT -> getCheckMessage [1713:24]
20132 | | | |--ELIST -> ELIST [1713:40]
20133 | | | | |--EXPR -> EXPR [1713:40]
20134 | | | | | `--IDENT -> MSG_CHILD_ERROR [1713:40]
20135 | | | | |--COMMA -> , [1713:55]
20136 | | | | |--EXPR -> EXPR [1713:57]
20137 | | | | | `--STRING_LITERAL -> "for" [1713:57]
20138 | | | | |--COMMA -> , [1713:62]
20139 | | | | |--EXPR -> EXPR [1713:64]
20140 | | | | | `--NUM_INT -> 14 [1713:64]
20141 | | | | |--COMMA -> , [1713:66]
20142 | | | | `--EXPR -> EXPR [1713:68]
20143 | | | | `--NUM_INT -> 16 [1713:68]
20144 | | | `--RPAREN -> ) [1713:70]
20145 | | |--COMMA -> , [1713:71]
20146 | | |--EXPR -> EXPR [1714:22]
20147 | | | `--PLUS -> + [1714:22]
20148 | | | |--STRING_LITERAL -> "72:11: " [1714:12]
20149 | | | `--METHOD_CALL -> ( [1714:39]
20150 | | | |--IDENT -> getCheckMessage [1714:24]
20151 | | | |--ELIST -> ELIST [1714:40]
20152 | | | | |--EXPR -> EXPR [1714:40]
20153 | | | | | `--IDENT -> MSG_CHILD_ERROR [1714:40]
20154 | | | | |--COMMA -> , [1714:55]
20155 | | | | |--EXPR -> EXPR [1714:57]
20156 | | | | | `--STRING_LITERAL -> "for" [1714:57]
20157 | | | | |--COMMA -> , [1714:62]
20158 | | | | |--EXPR -> EXPR [1714:64]
20159 | | | | | `--NUM_INT -> 10 [1714:64]
20160 | | | | |--COMMA -> , [1714:66]
20161 | | | | `--EXPR -> EXPR [1714:68]
20162 | | | | `--NUM_INT -> 12 [1714:68]
20163 | | | `--RPAREN -> ) [1714:70]
20164 | | |--COMMA -> , [1714:71]
20165 | | |--EXPR -> EXPR [1715:22]
20166 | | | `--PLUS -> + [1715:22]
20167 | | | |--STRING_LITERAL -> "81:13: " [1715:12]
20168 | | | `--METHOD_CALL -> ( [1715:39]
20169 | | | |--IDENT -> getCheckMessage [1715:24]
20170 | | | |--ELIST -> ELIST [1715:40]
20171 | | | | |--EXPR -> EXPR [1715:40]
20172 | | | | | `--IDENT -> MSG_ERROR [1715:40]
20173 | | | | |--COMMA -> , [1715:49]
20174 | | | | |--EXPR -> EXPR [1715:51]
20175 | | | | | `--STRING_LITERAL -> "for rparen" [1715:51]
20176 | | | | |--COMMA -> , [1715:63]
20177 | | | | |--EXPR -> EXPR [1715:65]
20178 | | | | | `--NUM_INT -> 12 [1715:65]
20179 | | | | |--COMMA -> , [1715:67]
20180 | | | | `--EXPR -> EXPR [1715:69]
20181 | | | | `--NUM_INT -> 8 [1715:69]
20182 | | | `--RPAREN -> ) [1715:70]
20183 | | |--COMMA -> , [1715:71]
20184 | | |--EXPR -> EXPR [1716:21]
20185 | | | `--PLUS -> + [1716:21]
20186 | | | |--STRING_LITERAL -> "86:3: " [1716:12]
20187 | | | `--METHOD_CALL -> ( [1716:38]
20188 | | | |--IDENT -> getCheckMessage [1716:23]
20189 | | | |--ELIST -> ELIST [1716:39]
20190 | | | | |--EXPR -> EXPR [1716:39]
20191 | | | | | `--IDENT -> MSG_ERROR [1716:39]
20192 | | | | |--COMMA -> , [1716:48]
20193 | | | | |--EXPR -> EXPR [1716:50]
20194 | | | | | `--STRING_LITERAL -> "method def modifier" [1716:50]
20195 | | | | |--COMMA -> , [1716:71]
20196 | | | | |--EXPR -> EXPR [1716:73]
20197 | | | | | `--NUM_INT -> 2 [1716:73]
20198 | | | | |--COMMA -> , [1716:74]
20199 | | | | `--EXPR -> EXPR [1716:76]
20200 | | | | `--NUM_INT -> 4 [1716:76]
20201 | | | `--RPAREN -> ) [1716:77]
20202 | | |--COMMA -> , [1716:78]
20203 | | |--EXPR -> EXPR [1717:21]
20204 | | | `--PLUS -> + [1717:21]
20205 | | | |--STRING_LITERAL -> "87:5: " [1717:12]
20206 | | | `--METHOD_CALL -> ( [1717:38]
20207 | | | |--IDENT -> getCheckMessage [1717:23]
20208 | | | |--ELIST -> ELIST [1717:39]
20209 | | | | |--EXPR -> EXPR [1717:39]
20210 | | | | | `--IDENT -> MSG_ERROR [1717:39]
20211 | | | | |--COMMA -> , [1717:48]
20212 | | | | |--EXPR -> EXPR [1717:50]
20213 | | | | | `--STRING_LITERAL -> "for" [1717:50]
20214 | | | | |--COMMA -> , [1717:55]
20215 | | | | |--EXPR -> EXPR [1717:57]
20216 | | | | | `--NUM_INT -> 4 [1717:57]
20217 | | | | |--COMMA -> , [1717:58]
20218 | | | | `--EXPR -> EXPR [1717:60]
20219 | | | | `--NUM_INT -> 8 [1717:60]
20220 | | | `--RPAREN -> ) [1717:61]
20221 | | |--COMMA -> , [1717:62]
20222 | | |--EXPR -> EXPR [1718:21]
20223 | | | `--PLUS -> + [1718:21]
20224 | | | |--STRING_LITERAL -> "88:9: " [1718:12]
20225 | | | `--METHOD_CALL -> ( [1718:38]
20226 | | | |--IDENT -> getCheckMessage [1718:23]
20227 | | | |--ELIST -> ELIST [1718:39]
20228 | | | | |--EXPR -> EXPR [1718:39]
20229 | | | | | `--IDENT -> MSG_CHILD_ERROR [1718:39]
20230 | | | | |--COMMA -> , [1718:54]
20231 | | | | |--EXPR -> EXPR [1718:56]
20232 | | | | | `--STRING_LITERAL -> "for" [1718:56]
20233 | | | | |--COMMA -> , [1718:61]
20234 | | | | |--EXPR -> EXPR [1718:63]
20235 | | | | | `--NUM_INT -> 8 [1718:63]
20236 | | | | |--COMMA -> , [1718:64]
20237 | | | | `--EXPR -> EXPR [1718:66]
20238 | | | | `--NUM_INT -> 12 [1718:66]
20239 | | | `--RPAREN -> ) [1718:68]
20240 | | |--COMMA -> , [1718:69]
20241 | | |--EXPR -> EXPR [1719:21]
20242 | | | `--PLUS -> + [1719:21]
20243 | | | |--STRING_LITERAL -> "89:7: " [1719:12]
20244 | | | `--METHOD_CALL -> ( [1719:38]
20245 | | | |--IDENT -> getCheckMessage [1719:23]
20246 | | | |--ELIST -> ELIST [1719:39]
20247 | | | | |--EXPR -> EXPR [1719:39]
20248 | | | | | `--IDENT -> MSG_CHILD_ERROR [1719:39]
20249 | | | | |--COMMA -> , [1719:54]
20250 | | | | |--EXPR -> EXPR [1719:56]
20251 | | | | | `--STRING_LITERAL -> "for" [1719:56]
20252 | | | | |--COMMA -> , [1719:61]
20253 | | | | |--EXPR -> EXPR [1719:63]
20254 | | | | | `--NUM_INT -> 6 [1719:63]
20255 | | | | |--COMMA -> , [1719:64]
20256 | | | | `--EXPR -> EXPR [1719:66]
20257 | | | | `--NUM_INT -> 12 [1719:66]
20258 | | | `--RPAREN -> ) [1719:68]
20259 | | |--COMMA -> , [1719:69]
20260 | | |--EXPR -> EXPR [1720:21]
20261 | | | `--PLUS -> + [1720:21]
20262 | | | |--STRING_LITERAL -> "90:9: " [1720:12]
20263 | | | `--METHOD_CALL -> ( [1720:38]
20264 | | | |--IDENT -> getCheckMessage [1720:23]
20265 | | | |--ELIST -> ELIST [1720:39]
20266 | | | | |--EXPR -> EXPR [1720:39]
20267 | | | | | `--IDENT -> MSG_CHILD_ERROR [1720:39]
20268 | | | | |--COMMA -> , [1720:54]
20269 | | | | |--EXPR -> EXPR [1720:56]
20270 | | | | | `--STRING_LITERAL -> "method call" [1720:56]
20271 | | | | |--COMMA -> , [1720:69]
20272 | | | | |--EXPR -> EXPR [1720:71]
20273 | | | | | `--NUM_INT -> 8 [1720:71]
20274 | | | | |--COMMA -> , [1720:72]
20275 | | | | `--EXPR -> EXPR [1720:74]
20276 | | | | `--NUM_INT -> 16 [1720:74]
20277 | | | `--RPAREN -> ) [1720:76]
20278 | | |--COMMA -> , [1720:77]
20279 | | |--EXPR -> EXPR [1721:21]
20280 | | | `--PLUS -> + [1721:21]
20281 | | | |--STRING_LITERAL -> "92:1: " [1721:12]
20282 | | | `--METHOD_CALL -> ( [1721:38]
20283 | | | |--IDENT -> getCheckMessage [1721:23]
20284 | | | |--ELIST -> ELIST [1721:39]
20285 | | | | |--EXPR -> EXPR [1721:39]
20286 | | | | | `--IDENT -> MSG_ERROR [1721:39]
20287 | | | | |--COMMA -> , [1721:48]
20288 | | | | |--EXPR -> EXPR [1721:50]
20289 | | | | | `--STRING_LITERAL -> "for" [1721:50]
20290 | | | | |--COMMA -> , [1721:55]
20291 | | | | |--EXPR -> EXPR [1721:57]
20292 | | | | | `--NUM_INT -> 0 [1721:57]
20293 | | | | |--COMMA -> , [1721:58]
20294 | | | | `--EXPR -> EXPR [1721:60]
20295 | | | | `--NUM_INT -> 8 [1721:60]
20296 | | | `--RPAREN -> ) [1721:61]
20297 | | |--COMMA -> , [1721:62]
20298 | | |--EXPR -> EXPR [1722:21]
20299 | | | `--PLUS -> + [1722:21]
20300 | | | |--STRING_LITERAL -> "93:1: " [1722:12]
20301 | | | `--METHOD_CALL -> ( [1722:38]
20302 | | | |--IDENT -> getCheckMessage [1722:23]
20303 | | | |--ELIST -> ELIST [1722:39]
20304 | | | | |--EXPR -> EXPR [1722:39]
20305 | | | | | `--IDENT -> MSG_ERROR [1722:39]
20306 | | | | |--COMMA -> , [1722:48]
20307 | | | | |--EXPR -> EXPR [1722:50]
20308 | | | | | `--STRING_LITERAL -> "for lparen" [1722:50]
20309 | | | | |--COMMA -> , [1722:62]
20310 | | | | |--EXPR -> EXPR [1722:64]
20311 | | | | | `--NUM_INT -> 0 [1722:64]
20312 | | | | |--COMMA -> , [1722:65]
20313 | | | | `--EXPR -> EXPR [1722:67]
20314 | | | | `--NUM_INT -> 8 [1722:67]
20315 | | | `--RPAREN -> ) [1722:68]
20316 | | |--COMMA -> , [1722:69]
20317 | | |--EXPR -> EXPR [1723:21]
20318 | | | `--PLUS -> + [1723:21]
20319 | | | |--STRING_LITERAL -> "94:1: " [1723:12]
20320 | | | `--METHOD_CALL -> ( [1723:38]
20321 | | | |--IDENT -> getCheckMessage [1723:23]
20322 | | | |--ELIST -> ELIST [1723:39]
20323 | | | | |--EXPR -> EXPR [1723:39]
20324 | | | | | `--IDENT -> MSG_CHILD_ERROR [1723:39]
20325 | | | | |--COMMA -> , [1723:54]
20326 | | | | |--EXPR -> EXPR [1723:56]
20327 | | | | | `--STRING_LITERAL -> "for" [1723:56]
20328 | | | | |--COMMA -> , [1723:61]
20329 | | | | |--EXPR -> EXPR [1723:63]
20330 | | | | | `--NUM_INT -> 0 [1723:63]
20331 | | | | |--COMMA -> , [1723:64]
20332 | | | | `--EXPR -> EXPR [1723:66]
20333 | | | | `--NUM_INT -> 12 [1723:66]
20334 | | | `--RPAREN -> ) [1723:68]
20335 | | |--COMMA -> , [1723:69]
20336 | | |--EXPR -> EXPR [1724:21]
20337 | | | `--PLUS -> + [1724:21]
20338 | | | |--STRING_LITERAL -> "95:1: " [1724:12]
20339 | | | `--METHOD_CALL -> ( [1724:38]
20340 | | | |--IDENT -> getCheckMessage [1724:23]
20341 | | | |--ELIST -> ELIST [1724:39]
20342 | | | | |--EXPR -> EXPR [1724:39]
20343 | | | | | `--IDENT -> MSG_ERROR [1724:39]
20344 | | | | |--COMMA -> , [1724:48]
20345 | | | | |--EXPR -> EXPR [1724:50]
20346 | | | | | `--STRING_LITERAL -> ";" [1724:50]
20347 | | | | |--COMMA -> , [1724:53]
20348 | | | | |--EXPR -> EXPR [1724:55]
20349 | | | | | `--NUM_INT -> 0 [1724:55]
20350 | | | | |--COMMA -> , [1724:56]
20351 | | | | `--EXPR -> EXPR [1724:58]
20352 | | | | `--NUM_INT -> 4 [1724:58]
20353 | | | `--RPAREN -> ) [1724:59]
20354 | | |--COMMA -> , [1724:60]
20355 | | |--EXPR -> EXPR [1725:21]
20356 | | | `--PLUS -> + [1725:21]
20357 | | | |--STRING_LITERAL -> "96:1: " [1725:12]
20358 | | | `--METHOD_CALL -> ( [1725:38]
20359 | | | |--IDENT -> getCheckMessage [1725:23]
20360 | | | |--ELIST -> ELIST [1725:39]
20361 | | | | |--EXPR -> EXPR [1725:39]
20362 | | | | | `--IDENT -> MSG_CHILD_ERROR [1725:39]
20363 | | | | |--COMMA -> , [1725:54]
20364 | | | | |--EXPR -> EXPR [1725:56]
20365 | | | | | `--STRING_LITERAL -> "for" [1725:56]
20366 | | | | |--COMMA -> , [1725:61]
20367 | | | | |--EXPR -> EXPR [1725:63]
20368 | | | | | `--NUM_INT -> 0 [1725:63]
20369 | | | | |--COMMA -> , [1725:64]
20370 | | | | `--EXPR -> EXPR [1725:66]
20371 | | | | `--NUM_INT -> 12 [1725:66]
20372 | | | `--RPAREN -> ) [1725:68]
20373 | | |--COMMA -> , [1725:69]
20374 | | |--EXPR -> EXPR [1726:21]
20375 | | | `--PLUS -> + [1726:21]
20376 | | | |--STRING_LITERAL -> "97:1: " [1726:12]
20377 | | | `--METHOD_CALL -> ( [1726:38]
20378 | | | |--IDENT -> getCheckMessage [1726:23]
20379 | | | |--ELIST -> ELIST [1726:39]
20380 | | | | |--EXPR -> EXPR [1726:39]
20381 | | | | | `--IDENT -> MSG_ERROR [1726:39]
20382 | | | | |--COMMA -> , [1726:48]
20383 | | | | |--EXPR -> EXPR [1726:50]
20384 | | | | | `--STRING_LITERAL -> ";" [1726:50]
20385 | | | | |--COMMA -> , [1726:53]
20386 | | | | |--EXPR -> EXPR [1726:55]
20387 | | | | | `--NUM_INT -> 0 [1726:55]
20388 | | | | |--COMMA -> , [1726:56]
20389 | | | | `--EXPR -> EXPR [1726:58]
20390 | | | | `--NUM_INT -> 4 [1726:58]
20391 | | | `--RPAREN -> ) [1726:59]
20392 | | |--COMMA -> , [1726:60]
20393 | | |--EXPR -> EXPR [1727:21]
20394 | | | `--PLUS -> + [1727:21]
20395 | | | |--STRING_LITERAL -> "98:1: " [1727:12]
20396 | | | `--METHOD_CALL -> ( [1727:38]
20397 | | | |--IDENT -> getCheckMessage [1727:23]
20398 | | | |--ELIST -> ELIST [1727:39]
20399 | | | | |--EXPR -> EXPR [1727:39]
20400 | | | | | `--IDENT -> MSG_CHILD_ERROR [1727:39]
20401 | | | | |--COMMA -> , [1727:54]
20402 | | | | |--EXPR -> EXPR [1727:56]
20403 | | | | | `--STRING_LITERAL -> "for" [1727:56]
20404 | | | | |--COMMA -> , [1727:61]
20405 | | | | |--EXPR -> EXPR [1727:63]
20406 | | | | | `--NUM_INT -> 0 [1727:63]
20407 | | | | |--COMMA -> , [1727:64]
20408 | | | | `--EXPR -> EXPR [1727:66]
20409 | | | | `--NUM_INT -> 12 [1727:66]
20410 | | | `--RPAREN -> ) [1727:68]
20411 | | |--COMMA -> , [1727:69]
20412 | | `--RCURLY -> } [1728:8]
20413 | |--SEMI -> ; [1728:9]
20414 | |--EXPR -> EXPR [1729:19]
20415 | | `--METHOD_CALL -> ( [1729:19]
20416 | | |--IDENT -> verifyWarns [1729:8]
20417 | | |--ELIST -> ELIST [1729:20]
20418 | | | |--EXPR -> EXPR [1729:20]
20419 | | | | `--IDENT -> checkConfig [1729:20]
20420 | | | |--COMMA -> , [1729:31]
20421 | | | |--EXPR -> EXPR [1729:33]
20422 | | | | `--IDENT -> fileName [1729:33]
20423 | | | |--COMMA -> , [1729:41]
20424 | | | `--EXPR -> EXPR [1729:43]
20425 | | | `--IDENT -> expected [1729:43]
20426 | | `--RPAREN -> ) [1729:51]
20427 | |--SEMI -> ; [1729:52]
20428 | `--RCURLY -> } [1730:4]
20429 |--METHOD_DEF -> METHOD_DEF [1732:4]
20430 | |--MODIFIERS -> MODIFIERS [1732:4]
20431 | | |--ANNOTATION -> ANNOTATION [1732:4]
20432 | | | |--AT -> @ [1732:4]
20433 | | | `--IDENT -> Test [1732:5]
20434 | | `--LITERAL_PUBLIC -> public [1733:4]
20435 | |--TYPE -> TYPE [1733:11]
20436 | | `--LITERAL_VOID -> void [1733:11]
20437 | |--IDENT -> testValidForWithChecker [1733:16]
20438 | |--LPAREN -> ( [1733:39]
20439 | |--PARAMETERS -> PARAMETERS [1733:40]
20440 | |--RPAREN -> ) [1733:40]
20441 | |--LITERAL_THROWS -> throws [1734:12]
20442 | | `--IDENT -> Exception [1734:19]
20443 | `--SLIST -> { [1734:29]
20444 | |--VARIABLE_DEF -> VARIABLE_DEF [1735:8]
20445 | | |--MODIFIERS -> MODIFIERS [1735:8]
20446 | | | `--FINAL -> final [1735:8]
20447 | | |--TYPE -> TYPE [1735:14]
20448 | | | `--IDENT -> DefaultConfiguration [1735:14]
20449 | | |--IDENT -> checkConfig [1735:35]
20450 | | `--ASSIGN -> = [1735:47]
20451 | | `--EXPR -> EXPR [1735:67]
20452 | | `--METHOD_CALL -> ( [1735:67]
20453 | | |--IDENT -> createModuleConfig [1735:49]
20454 | | |--ELIST -> ELIST [1735:84]
20455 | | | `--EXPR -> EXPR [1735:84]
20456 | | | `--DOT -> . [1735:84]
20457 | | | |--IDENT -> IndentationCheck [1735:68]
20458 | | | `--LITERAL_CLASS -> class [1735:85]
20459 | | `--RPAREN -> ) [1735:90]
20460 | |--SEMI -> ; [1735:91]
20461 | |--EXPR -> EXPR [1737:32]
20462 | | `--METHOD_CALL -> ( [1737:32]
20463 | | |--DOT -> . [1737:19]
20464 | | | |--IDENT -> checkConfig [1737:8]
20465 | | | `--IDENT -> addAttribute [1737:20]
20466 | | |--ELIST -> ELIST [1737:33]
20467 | | | |--EXPR -> EXPR [1737:33]
20468 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1737:33]
20469 | | | |--COMMA -> , [1737:50]
20470 | | | `--EXPR -> EXPR [1737:52]
20471 | | | `--STRING_LITERAL -> "4" [1737:52]
20472 | | `--RPAREN -> ) [1737:55]
20473 | |--SEMI -> ; [1737:56]
20474 | |--EXPR -> EXPR [1738:32]
20475 | | `--METHOD_CALL -> ( [1738:32]
20476 | | |--DOT -> . [1738:19]
20477 | | | |--IDENT -> checkConfig [1738:8]
20478 | | | `--IDENT -> addAttribute [1738:20]
20479 | | |--ELIST -> ELIST [1738:33]
20480 | | | |--EXPR -> EXPR [1738:33]
20481 | | | | `--STRING_LITERAL -> "basicOffset" [1738:33]
20482 | | | |--COMMA -> , [1738:46]
20483 | | | `--EXPR -> EXPR [1738:48]
20484 | | | `--STRING_LITERAL -> "4" [1738:48]
20485 | | `--RPAREN -> ) [1738:51]
20486 | |--SEMI -> ; [1738:52]
20487 | |--EXPR -> EXPR [1739:32]
20488 | | `--METHOD_CALL -> ( [1739:32]
20489 | | |--DOT -> . [1739:19]
20490 | | | |--IDENT -> checkConfig [1739:8]
20491 | | | `--IDENT -> addAttribute [1739:20]
20492 | | |--ELIST -> ELIST [1739:33]
20493 | | | |--EXPR -> EXPR [1739:33]
20494 | | | | `--STRING_LITERAL -> "braceAdjustment" [1739:33]
20495 | | | |--COMMA -> , [1739:50]
20496 | | | `--EXPR -> EXPR [1739:52]
20497 | | | `--STRING_LITERAL -> "0" [1739:52]
20498 | | `--RPAREN -> ) [1739:55]
20499 | |--SEMI -> ; [1739:56]
20500 | |--EXPR -> EXPR [1740:32]
20501 | | `--METHOD_CALL -> ( [1740:32]
20502 | | |--DOT -> . [1740:19]
20503 | | | |--IDENT -> checkConfig [1740:8]
20504 | | | `--IDENT -> addAttribute [1740:20]
20505 | | |--ELIST -> ELIST [1740:33]
20506 | | | |--EXPR -> EXPR [1740:33]
20507 | | | | `--STRING_LITERAL -> "caseIndent" [1740:33]
20508 | | | |--COMMA -> , [1740:45]
20509 | | | `--EXPR -> EXPR [1740:47]
20510 | | | `--STRING_LITERAL -> "4" [1740:47]
20511 | | `--RPAREN -> ) [1740:50]
20512 | |--SEMI -> ; [1740:51]
20513 | |--EXPR -> EXPR [1741:32]
20514 | | `--METHOD_CALL -> ( [1741:32]
20515 | | |--DOT -> . [1741:19]
20516 | | | |--IDENT -> checkConfig [1741:8]
20517 | | | `--IDENT -> addAttribute [1741:20]
20518 | | |--ELIST -> ELIST [1741:33]
20519 | | | |--EXPR -> EXPR [1741:33]
20520 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1741:33]
20521 | | | |--COMMA -> , [1741:55]
20522 | | | `--EXPR -> EXPR [1741:57]
20523 | | | `--STRING_LITERAL -> "false" [1741:57]
20524 | | `--RPAREN -> ) [1741:64]
20525 | |--SEMI -> ; [1741:65]
20526 | |--EXPR -> EXPR [1742:32]
20527 | | `--METHOD_CALL -> ( [1742:32]
20528 | | |--DOT -> . [1742:19]
20529 | | | |--IDENT -> checkConfig [1742:8]
20530 | | | `--IDENT -> addAttribute [1742:20]
20531 | | |--ELIST -> ELIST [1742:33]
20532 | | | |--EXPR -> EXPR [1742:33]
20533 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1742:33]
20534 | | | |--COMMA -> , [1742:58]
20535 | | | `--EXPR -> EXPR [1742:60]
20536 | | | `--STRING_LITERAL -> "4" [1742:60]
20537 | | `--RPAREN -> ) [1742:63]
20538 | |--SEMI -> ; [1742:64]
20539 | |--EXPR -> EXPR [1743:32]
20540 | | `--METHOD_CALL -> ( [1743:32]
20541 | | |--DOT -> . [1743:19]
20542 | | | |--IDENT -> checkConfig [1743:8]
20543 | | | `--IDENT -> addAttribute [1743:20]
20544 | | |--ELIST -> ELIST [1743:33]
20545 | | | |--EXPR -> EXPR [1743:33]
20546 | | | | `--STRING_LITERAL -> "tabWidth" [1743:33]
20547 | | | |--COMMA -> , [1743:43]
20548 | | | `--EXPR -> EXPR [1743:45]
20549 | | | `--STRING_LITERAL -> "4" [1743:45]
20550 | | `--RPAREN -> ) [1743:48]
20551 | |--SEMI -> ; [1743:49]
20552 | |--EXPR -> EXPR [1744:32]
20553 | | `--METHOD_CALL -> ( [1744:32]
20554 | | |--DOT -> . [1744:19]
20555 | | | |--IDENT -> checkConfig [1744:8]
20556 | | | `--IDENT -> addAttribute [1744:20]
20557 | | |--ELIST -> ELIST [1744:33]
20558 | | | |--EXPR -> EXPR [1744:33]
20559 | | | | `--STRING_LITERAL -> "throwsIndent" [1744:33]
20560 | | | |--COMMA -> , [1744:47]
20561 | | | `--EXPR -> EXPR [1744:49]
20562 | | | `--STRING_LITERAL -> "4" [1744:49]
20563 | | `--RPAREN -> ) [1744:52]
20564 | |--SEMI -> ; [1744:53]
20565 | |--VARIABLE_DEF -> VARIABLE_DEF [1745:8]
20566 | | |--MODIFIERS -> MODIFIERS [1745:8]
20567 | | | `--FINAL -> final [1745:8]
20568 | | |--TYPE -> TYPE [1745:14]
20569 | | | `--IDENT -> String [1745:14]
20570 | | |--IDENT -> fileName [1745:21]
20571 | | `--ASSIGN -> = [1745:30]
20572 | | `--EXPR -> EXPR [1745:39]
20573 | | `--METHOD_CALL -> ( [1745:39]
20574 | | |--IDENT -> getPath [1745:32]
20575 | | |--ELIST -> ELIST [1745:40]
20576 | | | `--EXPR -> EXPR [1745:40]
20577 | | | `--STRING_LITERAL -> "InputIndentationValidForIndent.java" [1745:40]
20578 | | `--RPAREN -> ) [1745:77]
20579 | |--SEMI -> ; [1745:78]
20580 | |--VARIABLE_DEF -> VARIABLE_DEF [1746:8]
20581 | | |--MODIFIERS -> MODIFIERS [1746:8]
20582 | | | `--FINAL -> final [1746:8]
20583 | | |--TYPE -> TYPE [1746:20]
20584 | | | `--ARRAY_DECLARATOR -> [ [1746:20]
20585 | | | |--IDENT -> String [1746:14]
20586 | | | `--RBRACK -> ] [1746:21]
20587 | | |--IDENT -> expected [1746:23]
20588 | | `--ASSIGN -> = [1746:32]
20589 | | `--EXPR -> EXPR [1746:44]
20590 | | `--DOT -> . [1746:44]
20591 | | |--IDENT -> CommonUtil [1746:34]
20592 | | `--IDENT -> EMPTY_STRING_ARRAY [1746:45]
20593 | |--SEMI -> ; [1746:63]
20594 | |--EXPR -> EXPR [1747:19]
20595 | | `--METHOD_CALL -> ( [1747:19]
20596 | | |--IDENT -> verifyWarns [1747:8]
20597 | | |--ELIST -> ELIST [1747:20]
20598 | | | |--EXPR -> EXPR [1747:20]
20599 | | | | `--IDENT -> checkConfig [1747:20]
20600 | | | |--COMMA -> , [1747:31]
20601 | | | |--EXPR -> EXPR [1747:33]
20602 | | | | `--IDENT -> fileName [1747:33]
20603 | | | |--COMMA -> , [1747:41]
20604 | | | `--EXPR -> EXPR [1747:43]
20605 | | | `--IDENT -> expected [1747:43]
20606 | | `--RPAREN -> ) [1747:51]
20607 | |--SEMI -> ; [1747:52]
20608 | `--RCURLY -> } [1748:4]
20609 |--METHOD_DEF -> METHOD_DEF [1750:4]
20610 | |--MODIFIERS -> MODIFIERS [1750:4]
20611 | | |--ANNOTATION -> ANNOTATION [1750:4]
20612 | | | |--AT -> @ [1750:4]
20613 | | | `--IDENT -> Test [1750:5]
20614 | | `--LITERAL_PUBLIC -> public [1751:4]
20615 | |--TYPE -> TYPE [1751:11]
20616 | | `--LITERAL_VOID -> void [1751:11]
20617 | |--IDENT -> testValidDoWhileWithChecker [1751:16]
20618 | |--LPAREN -> ( [1751:43]
20619 | |--PARAMETERS -> PARAMETERS [1751:44]
20620 | |--RPAREN -> ) [1751:44]
20621 | |--LITERAL_THROWS -> throws [1752:12]
20622 | | `--IDENT -> Exception [1752:19]
20623 | `--SLIST -> { [1752:29]
20624 | |--VARIABLE_DEF -> VARIABLE_DEF [1753:8]
20625 | | |--MODIFIERS -> MODIFIERS [1753:8]
20626 | | | `--FINAL -> final [1753:8]
20627 | | |--TYPE -> TYPE [1753:14]
20628 | | | `--IDENT -> DefaultConfiguration [1753:14]
20629 | | |--IDENT -> checkConfig [1753:35]
20630 | | `--ASSIGN -> = [1753:47]
20631 | | `--EXPR -> EXPR [1753:67]
20632 | | `--METHOD_CALL -> ( [1753:67]
20633 | | |--IDENT -> createModuleConfig [1753:49]
20634 | | |--ELIST -> ELIST [1753:84]
20635 | | | `--EXPR -> EXPR [1753:84]
20636 | | | `--DOT -> . [1753:84]
20637 | | | |--IDENT -> IndentationCheck [1753:68]
20638 | | | `--LITERAL_CLASS -> class [1753:85]
20639 | | `--RPAREN -> ) [1753:90]
20640 | |--SEMI -> ; [1753:91]
20641 | |--EXPR -> EXPR [1755:32]
20642 | | `--METHOD_CALL -> ( [1755:32]
20643 | | |--DOT -> . [1755:19]
20644 | | | |--IDENT -> checkConfig [1755:8]
20645 | | | `--IDENT -> addAttribute [1755:20]
20646 | | |--ELIST -> ELIST [1755:33]
20647 | | | |--EXPR -> EXPR [1755:33]
20648 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1755:33]
20649 | | | |--COMMA -> , [1755:50]
20650 | | | `--EXPR -> EXPR [1755:52]
20651 | | | `--STRING_LITERAL -> "4" [1755:52]
20652 | | `--RPAREN -> ) [1755:55]
20653 | |--SEMI -> ; [1755:56]
20654 | |--EXPR -> EXPR [1756:32]
20655 | | `--METHOD_CALL -> ( [1756:32]
20656 | | |--DOT -> . [1756:19]
20657 | | | |--IDENT -> checkConfig [1756:8]
20658 | | | `--IDENT -> addAttribute [1756:20]
20659 | | |--ELIST -> ELIST [1756:33]
20660 | | | |--EXPR -> EXPR [1756:33]
20661 | | | | `--STRING_LITERAL -> "basicOffset" [1756:33]
20662 | | | |--COMMA -> , [1756:46]
20663 | | | `--EXPR -> EXPR [1756:48]
20664 | | | `--STRING_LITERAL -> "4" [1756:48]
20665 | | `--RPAREN -> ) [1756:51]
20666 | |--SEMI -> ; [1756:52]
20667 | |--EXPR -> EXPR [1757:32]
20668 | | `--METHOD_CALL -> ( [1757:32]
20669 | | |--DOT -> . [1757:19]
20670 | | | |--IDENT -> checkConfig [1757:8]
20671 | | | `--IDENT -> addAttribute [1757:20]
20672 | | |--ELIST -> ELIST [1757:33]
20673 | | | |--EXPR -> EXPR [1757:33]
20674 | | | | `--STRING_LITERAL -> "braceAdjustment" [1757:33]
20675 | | | |--COMMA -> , [1757:50]
20676 | | | `--EXPR -> EXPR [1757:52]
20677 | | | `--STRING_LITERAL -> "0" [1757:52]
20678 | | `--RPAREN -> ) [1757:55]
20679 | |--SEMI -> ; [1757:56]
20680 | |--EXPR -> EXPR [1758:32]
20681 | | `--METHOD_CALL -> ( [1758:32]
20682 | | |--DOT -> . [1758:19]
20683 | | | |--IDENT -> checkConfig [1758:8]
20684 | | | `--IDENT -> addAttribute [1758:20]
20685 | | |--ELIST -> ELIST [1758:33]
20686 | | | |--EXPR -> EXPR [1758:33]
20687 | | | | `--STRING_LITERAL -> "caseIndent" [1758:33]
20688 | | | |--COMMA -> , [1758:45]
20689 | | | `--EXPR -> EXPR [1758:47]
20690 | | | `--STRING_LITERAL -> "4" [1758:47]
20691 | | `--RPAREN -> ) [1758:50]
20692 | |--SEMI -> ; [1758:51]
20693 | |--EXPR -> EXPR [1759:32]
20694 | | `--METHOD_CALL -> ( [1759:32]
20695 | | |--DOT -> . [1759:19]
20696 | | | |--IDENT -> checkConfig [1759:8]
20697 | | | `--IDENT -> addAttribute [1759:20]
20698 | | |--ELIST -> ELIST [1759:33]
20699 | | | |--EXPR -> EXPR [1759:33]
20700 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1759:33]
20701 | | | |--COMMA -> , [1759:55]
20702 | | | `--EXPR -> EXPR [1759:57]
20703 | | | `--STRING_LITERAL -> "false" [1759:57]
20704 | | `--RPAREN -> ) [1759:64]
20705 | |--SEMI -> ; [1759:65]
20706 | |--EXPR -> EXPR [1760:32]
20707 | | `--METHOD_CALL -> ( [1760:32]
20708 | | |--DOT -> . [1760:19]
20709 | | | |--IDENT -> checkConfig [1760:8]
20710 | | | `--IDENT -> addAttribute [1760:20]
20711 | | |--ELIST -> ELIST [1760:33]
20712 | | | |--EXPR -> EXPR [1760:33]
20713 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1760:33]
20714 | | | |--COMMA -> , [1760:58]
20715 | | | `--EXPR -> EXPR [1760:60]
20716 | | | `--STRING_LITERAL -> "4" [1760:60]
20717 | | `--RPAREN -> ) [1760:63]
20718 | |--SEMI -> ; [1760:64]
20719 | |--EXPR -> EXPR [1761:32]
20720 | | `--METHOD_CALL -> ( [1761:32]
20721 | | |--DOT -> . [1761:19]
20722 | | | |--IDENT -> checkConfig [1761:8]
20723 | | | `--IDENT -> addAttribute [1761:20]
20724 | | |--ELIST -> ELIST [1761:33]
20725 | | | |--EXPR -> EXPR [1761:33]
20726 | | | | `--STRING_LITERAL -> "tabWidth" [1761:33]
20727 | | | |--COMMA -> , [1761:43]
20728 | | | `--EXPR -> EXPR [1761:45]
20729 | | | `--STRING_LITERAL -> "4" [1761:45]
20730 | | `--RPAREN -> ) [1761:48]
20731 | |--SEMI -> ; [1761:49]
20732 | |--EXPR -> EXPR [1762:32]
20733 | | `--METHOD_CALL -> ( [1762:32]
20734 | | |--DOT -> . [1762:19]
20735 | | | |--IDENT -> checkConfig [1762:8]
20736 | | | `--IDENT -> addAttribute [1762:20]
20737 | | |--ELIST -> ELIST [1762:33]
20738 | | | |--EXPR -> EXPR [1762:33]
20739 | | | | `--STRING_LITERAL -> "throwsIndent" [1762:33]
20740 | | | |--COMMA -> , [1762:47]
20741 | | | `--EXPR -> EXPR [1762:49]
20742 | | | `--STRING_LITERAL -> "4" [1762:49]
20743 | | `--RPAREN -> ) [1762:52]
20744 | |--SEMI -> ; [1762:53]
20745 | |--VARIABLE_DEF -> VARIABLE_DEF [1763:8]
20746 | | |--MODIFIERS -> MODIFIERS [1763:8]
20747 | | | `--FINAL -> final [1763:8]
20748 | | |--TYPE -> TYPE [1763:14]
20749 | | | `--IDENT -> String [1763:14]
20750 | | |--IDENT -> fileName [1763:21]
20751 | | `--ASSIGN -> = [1763:30]
20752 | | `--EXPR -> EXPR [1763:39]
20753 | | `--METHOD_CALL -> ( [1763:39]
20754 | | |--IDENT -> getPath [1763:32]
20755 | | |--ELIST -> ELIST [1763:40]
20756 | | | `--EXPR -> EXPR [1763:40]
20757 | | | `--STRING_LITERAL -> "InputIndentationValidDoWhileIndent.java" [1763:40]
20758 | | `--RPAREN -> ) [1763:81]
20759 | |--SEMI -> ; [1763:82]
20760 | |--VARIABLE_DEF -> VARIABLE_DEF [1764:8]
20761 | | |--MODIFIERS -> MODIFIERS [1764:8]
20762 | | | `--FINAL -> final [1764:8]
20763 | | |--TYPE -> TYPE [1764:20]
20764 | | | `--ARRAY_DECLARATOR -> [ [1764:20]
20765 | | | |--IDENT -> String [1764:14]
20766 | | | `--RBRACK -> ] [1764:21]
20767 | | |--IDENT -> expected [1764:23]
20768 | | `--ASSIGN -> = [1764:32]
20769 | | `--EXPR -> EXPR [1764:44]
20770 | | `--DOT -> . [1764:44]
20771 | | |--IDENT -> CommonUtil [1764:34]
20772 | | `--IDENT -> EMPTY_STRING_ARRAY [1764:45]
20773 | |--SEMI -> ; [1764:63]
20774 | |--EXPR -> EXPR [1765:19]
20775 | | `--METHOD_CALL -> ( [1765:19]
20776 | | |--IDENT -> verifyWarns [1765:8]
20777 | | |--ELIST -> ELIST [1765:20]
20778 | | | |--EXPR -> EXPR [1765:20]
20779 | | | | `--IDENT -> checkConfig [1765:20]
20780 | | | |--COMMA -> , [1765:31]
20781 | | | |--EXPR -> EXPR [1765:33]
20782 | | | | `--IDENT -> fileName [1765:33]
20783 | | | |--COMMA -> , [1765:41]
20784 | | | `--EXPR -> EXPR [1765:43]
20785 | | | `--IDENT -> expected [1765:43]
20786 | | `--RPAREN -> ) [1765:51]
20787 | |--SEMI -> ; [1765:52]
20788 | `--RCURLY -> } [1766:4]
20789 |--METHOD_DEF -> METHOD_DEF [1768:4]
20790 | |--MODIFIERS -> MODIFIERS [1768:4]
20791 | | |--ANNOTATION -> ANNOTATION [1768:4]
20792 | | | |--AT -> @ [1768:4]
20793 | | | `--IDENT -> Test [1768:5]
20794 | | `--LITERAL_PUBLIC -> public [1769:4]
20795 | |--TYPE -> TYPE [1769:11]
20796 | | `--LITERAL_VOID -> void [1769:11]
20797 | |--IDENT -> testInvalidDoWhileWithChecker [1769:16]
20798 | |--LPAREN -> ( [1769:45]
20799 | |--PARAMETERS -> PARAMETERS [1769:46]
20800 | |--RPAREN -> ) [1769:46]
20801 | |--LITERAL_THROWS -> throws [1770:12]
20802 | | `--IDENT -> Exception [1770:19]
20803 | `--SLIST -> { [1770:29]
20804 | |--VARIABLE_DEF -> VARIABLE_DEF [1771:8]
20805 | | |--MODIFIERS -> MODIFIERS [1771:8]
20806 | | | `--FINAL -> final [1771:8]
20807 | | |--TYPE -> TYPE [1771:14]
20808 | | | `--IDENT -> DefaultConfiguration [1771:14]
20809 | | |--IDENT -> checkConfig [1771:35]
20810 | | `--ASSIGN -> = [1771:47]
20811 | | `--EXPR -> EXPR [1771:67]
20812 | | `--METHOD_CALL -> ( [1771:67]
20813 | | |--IDENT -> createModuleConfig [1771:49]
20814 | | |--ELIST -> ELIST [1771:84]
20815 | | | `--EXPR -> EXPR [1771:84]
20816 | | | `--DOT -> . [1771:84]
20817 | | | |--IDENT -> IndentationCheck [1771:68]
20818 | | | `--LITERAL_CLASS -> class [1771:85]
20819 | | `--RPAREN -> ) [1771:90]
20820 | |--SEMI -> ; [1771:91]
20821 | |--EXPR -> EXPR [1773:32]
20822 | | `--METHOD_CALL -> ( [1773:32]
20823 | | |--DOT -> . [1773:19]
20824 | | | |--IDENT -> checkConfig [1773:8]
20825 | | | `--IDENT -> addAttribute [1773:20]
20826 | | |--ELIST -> ELIST [1773:33]
20827 | | | |--EXPR -> EXPR [1773:33]
20828 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1773:33]
20829 | | | |--COMMA -> , [1773:50]
20830 | | | `--EXPR -> EXPR [1773:52]
20831 | | | `--STRING_LITERAL -> "4" [1773:52]
20832 | | `--RPAREN -> ) [1773:55]
20833 | |--SEMI -> ; [1773:56]
20834 | |--EXPR -> EXPR [1774:32]
20835 | | `--METHOD_CALL -> ( [1774:32]
20836 | | |--DOT -> . [1774:19]
20837 | | | |--IDENT -> checkConfig [1774:8]
20838 | | | `--IDENT -> addAttribute [1774:20]
20839 | | |--ELIST -> ELIST [1774:33]
20840 | | | |--EXPR -> EXPR [1774:33]
20841 | | | | `--STRING_LITERAL -> "basicOffset" [1774:33]
20842 | | | |--COMMA -> , [1774:46]
20843 | | | `--EXPR -> EXPR [1774:48]
20844 | | | `--STRING_LITERAL -> "4" [1774:48]
20845 | | `--RPAREN -> ) [1774:51]
20846 | |--SEMI -> ; [1774:52]
20847 | |--EXPR -> EXPR [1775:32]
20848 | | `--METHOD_CALL -> ( [1775:32]
20849 | | |--DOT -> . [1775:19]
20850 | | | |--IDENT -> checkConfig [1775:8]
20851 | | | `--IDENT -> addAttribute [1775:20]
20852 | | |--ELIST -> ELIST [1775:33]
20853 | | | |--EXPR -> EXPR [1775:33]
20854 | | | | `--STRING_LITERAL -> "braceAdjustment" [1775:33]
20855 | | | |--COMMA -> , [1775:50]
20856 | | | `--EXPR -> EXPR [1775:52]
20857 | | | `--STRING_LITERAL -> "0" [1775:52]
20858 | | `--RPAREN -> ) [1775:55]
20859 | |--SEMI -> ; [1775:56]
20860 | |--EXPR -> EXPR [1776:32]
20861 | | `--METHOD_CALL -> ( [1776:32]
20862 | | |--DOT -> . [1776:19]
20863 | | | |--IDENT -> checkConfig [1776:8]
20864 | | | `--IDENT -> addAttribute [1776:20]
20865 | | |--ELIST -> ELIST [1776:33]
20866 | | | |--EXPR -> EXPR [1776:33]
20867 | | | | `--STRING_LITERAL -> "caseIndent" [1776:33]
20868 | | | |--COMMA -> , [1776:45]
20869 | | | `--EXPR -> EXPR [1776:47]
20870 | | | `--STRING_LITERAL -> "4" [1776:47]
20871 | | `--RPAREN -> ) [1776:50]
20872 | |--SEMI -> ; [1776:51]
20873 | |--EXPR -> EXPR [1777:32]
20874 | | `--METHOD_CALL -> ( [1777:32]
20875 | | |--DOT -> . [1777:19]
20876 | | | |--IDENT -> checkConfig [1777:8]
20877 | | | `--IDENT -> addAttribute [1777:20]
20878 | | |--ELIST -> ELIST [1777:33]
20879 | | | |--EXPR -> EXPR [1777:33]
20880 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1777:33]
20881 | | | |--COMMA -> , [1777:55]
20882 | | | `--EXPR -> EXPR [1777:57]
20883 | | | `--STRING_LITERAL -> "false" [1777:57]
20884 | | `--RPAREN -> ) [1777:64]
20885 | |--SEMI -> ; [1777:65]
20886 | |--EXPR -> EXPR [1778:32]
20887 | | `--METHOD_CALL -> ( [1778:32]
20888 | | |--DOT -> . [1778:19]
20889 | | | |--IDENT -> checkConfig [1778:8]
20890 | | | `--IDENT -> addAttribute [1778:20]
20891 | | |--ELIST -> ELIST [1778:33]
20892 | | | |--EXPR -> EXPR [1778:33]
20893 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1778:33]
20894 | | | |--COMMA -> , [1778:58]
20895 | | | `--EXPR -> EXPR [1778:60]
20896 | | | `--STRING_LITERAL -> "4" [1778:60]
20897 | | `--RPAREN -> ) [1778:63]
20898 | |--SEMI -> ; [1778:64]
20899 | |--EXPR -> EXPR [1779:32]
20900 | | `--METHOD_CALL -> ( [1779:32]
20901 | | |--DOT -> . [1779:19]
20902 | | | |--IDENT -> checkConfig [1779:8]
20903 | | | `--IDENT -> addAttribute [1779:20]
20904 | | |--ELIST -> ELIST [1779:33]
20905 | | | |--EXPR -> EXPR [1779:33]
20906 | | | | `--STRING_LITERAL -> "tabWidth" [1779:33]
20907 | | | |--COMMA -> , [1779:43]
20908 | | | `--EXPR -> EXPR [1779:45]
20909 | | | `--STRING_LITERAL -> "4" [1779:45]
20910 | | `--RPAREN -> ) [1779:48]
20911 | |--SEMI -> ; [1779:49]
20912 | |--EXPR -> EXPR [1780:32]
20913 | | `--METHOD_CALL -> ( [1780:32]
20914 | | |--DOT -> . [1780:19]
20915 | | | |--IDENT -> checkConfig [1780:8]
20916 | | | `--IDENT -> addAttribute [1780:20]
20917 | | |--ELIST -> ELIST [1780:33]
20918 | | | |--EXPR -> EXPR [1780:33]
20919 | | | | `--STRING_LITERAL -> "throwsIndent" [1780:33]
20920 | | | |--COMMA -> , [1780:47]
20921 | | | `--EXPR -> EXPR [1780:49]
20922 | | | `--STRING_LITERAL -> "4" [1780:49]
20923 | | `--RPAREN -> ) [1780:52]
20924 | |--SEMI -> ; [1780:53]
20925 | |--VARIABLE_DEF -> VARIABLE_DEF [1781:8]
20926 | | |--MODIFIERS -> MODIFIERS [1781:8]
20927 | | | `--FINAL -> final [1781:8]
20928 | | |--TYPE -> TYPE [1781:14]
20929 | | | `--IDENT -> String [1781:14]
20930 | | |--IDENT -> fileName [1781:21]
20931 | | `--ASSIGN -> = [1781:30]
20932 | | `--EXPR -> EXPR [1781:39]
20933 | | `--METHOD_CALL -> ( [1781:39]
20934 | | |--IDENT -> getPath [1781:32]
20935 | | |--ELIST -> ELIST [1781:40]
20936 | | | `--EXPR -> EXPR [1781:40]
20937 | | | `--STRING_LITERAL -> "InputIndentationInvalidDoWhileIndent.java" [1781:40]
20938 | | `--RPAREN -> ) [1781:83]
20939 | |--SEMI -> ; [1781:84]
20940 | |--VARIABLE_DEF -> VARIABLE_DEF [1782:8]
20941 | | |--MODIFIERS -> MODIFIERS [1782:8]
20942 | | | `--FINAL -> final [1782:8]
20943 | | |--TYPE -> TYPE [1782:20]
20944 | | | `--ARRAY_DECLARATOR -> [ [1782:20]
20945 | | | |--IDENT -> String [1782:14]
20946 | | | `--RBRACK -> ] [1782:21]
20947 | | |--IDENT -> expected [1782:23]
20948 | | `--ASSIGN -> = [1782:32]
20949 | | `--ARRAY_INIT -> { [1782:34]
20950 | | |--EXPR -> EXPR [1783:20]
20951 | | | `--PLUS -> + [1783:20]
20952 | | | |--STRING_LITERAL -> "7:1: " [1783:12]
20953 | | | `--METHOD_CALL -> ( [1783:37]
20954 | | | |--IDENT -> getCheckMessage [1783:22]
20955 | | | |--ELIST -> ELIST [1783:38]
20956 | | | | |--EXPR -> EXPR [1783:38]
20957 | | | | | `--IDENT -> MSG_ERROR [1783:38]
20958 | | | | |--COMMA -> , [1783:47]
20959 | | | | |--EXPR -> EXPR [1783:49]
20960 | | | | | `--STRING_LITERAL -> "do..while" [1783:49]
20961 | | | | |--COMMA -> , [1783:60]
20962 | | | | |--EXPR -> EXPR [1783:62]
20963 | | | | | `--NUM_INT -> 0 [1783:62]
20964 | | | | |--COMMA -> , [1783:63]
20965 | | | | `--EXPR -> EXPR [1783:65]
20966 | | | | `--NUM_INT -> 8 [1783:65]
20967 | | | `--RPAREN -> ) [1783:66]
20968 | | |--COMMA -> , [1783:67]
20969 | | |--EXPR -> EXPR [1784:20]
20970 | | | `--PLUS -> + [1784:20]
20971 | | | |--STRING_LITERAL -> "8:1: " [1784:12]
20972 | | | `--METHOD_CALL -> ( [1784:37]
20973 | | | |--IDENT -> getCheckMessage [1784:22]
20974 | | | |--ELIST -> ELIST [1784:38]
20975 | | | | |--EXPR -> EXPR [1784:38]
20976 | | | | | `--IDENT -> MSG_ERROR [1784:38]
20977 | | | | |--COMMA -> , [1784:47]
20978 | | | | |--EXPR -> EXPR [1784:49]
20979 | | | | | `--STRING_LITERAL -> "do..while" [1784:49]
20980 | | | | |--COMMA -> , [1784:60]
20981 | | | | |--EXPR -> EXPR [1784:62]
20982 | | | | | `--NUM_INT -> 0 [1784:62]
20983 | | | | |--COMMA -> , [1784:63]
20984 | | | | `--EXPR -> EXPR [1784:65]
20985 | | | | `--NUM_INT -> 8 [1784:65]
20986 | | | `--RPAREN -> ) [1784:66]
20987 | | |--COMMA -> , [1784:67]
20988 | | |--EXPR -> EXPR [1785:20]
20989 | | | `--PLUS -> + [1785:20]
20990 | | | |--STRING_LITERAL -> "9:1: " [1785:12]
20991 | | | `--METHOD_CALL -> ( [1785:37]
20992 | | | |--IDENT -> getCheckMessage [1785:22]
20993 | | | |--ELIST -> ELIST [1785:38]
20994 | | | | |--EXPR -> EXPR [1785:38]
20995 | | | | | `--IDENT -> MSG_ERROR [1785:38]
20996 | | | | |--COMMA -> , [1785:47]
20997 | | | | |--EXPR -> EXPR [1785:49]
20998 | | | | | `--STRING_LITERAL -> "do..while" [1785:49]
20999 | | | | |--COMMA -> , [1785:60]
21000 | | | | |--EXPR -> EXPR [1785:62]
21001 | | | | | `--NUM_INT -> 0 [1785:62]
21002 | | | | |--COMMA -> , [1785:63]
21003 | | | | `--EXPR -> EXPR [1785:65]
21004 | | | | `--NUM_INT -> 8 [1785:65]
21005 | | | `--RPAREN -> ) [1785:66]
21006 | | |--COMMA -> , [1785:67]
21007 | | |--EXPR -> EXPR [1786:21]
21008 | | | `--PLUS -> + [1786:21]
21009 | | | |--STRING_LITERAL -> "10:1: " [1786:12]
21010 | | | `--METHOD_CALL -> ( [1786:38]
21011 | | | |--IDENT -> getCheckMessage [1786:23]
21012 | | | |--ELIST -> ELIST [1786:39]
21013 | | | | |--EXPR -> EXPR [1786:39]
21014 | | | | | `--IDENT -> MSG_ERROR [1786:39]
21015 | | | | |--COMMA -> , [1786:48]
21016 | | | | |--EXPR -> EXPR [1786:50]
21017 | | | | | `--STRING_LITERAL -> "do..while rcurly" [1786:50]
21018 | | | | |--COMMA -> , [1786:68]
21019 | | | | |--EXPR -> EXPR [1786:70]
21020 | | | | | `--NUM_INT -> 0 [1786:70]
21021 | | | | |--COMMA -> , [1786:71]
21022 | | | | `--EXPR -> EXPR [1786:73]
21023 | | | | `--NUM_INT -> 8 [1786:73]
21024 | | | `--RPAREN -> ) [1786:74]
21025 | | |--COMMA -> , [1786:75]
21026 | | |--EXPR -> EXPR [1787:21]
21027 | | | `--PLUS -> + [1787:21]
21028 | | | |--STRING_LITERAL -> "11:1: " [1787:12]
21029 | | | `--METHOD_CALL -> ( [1787:38]
21030 | | | |--IDENT -> getCheckMessage [1787:23]
21031 | | | |--ELIST -> ELIST [1787:39]
21032 | | | | |--EXPR -> EXPR [1787:39]
21033 | | | | | `--IDENT -> MSG_ERROR [1787:39]
21034 | | | | |--COMMA -> , [1787:48]
21035 | | | | |--EXPR -> EXPR [1787:50]
21036 | | | | | `--STRING_LITERAL -> "do..while" [1787:50]
21037 | | | | |--COMMA -> , [1787:61]
21038 | | | | |--EXPR -> EXPR [1787:63]
21039 | | | | | `--NUM_INT -> 0 [1787:63]
21040 | | | | |--COMMA -> , [1787:64]
21041 | | | | `--EXPR -> EXPR [1787:66]
21042 | | | | `--NUM_INT -> 8 [1787:66]
21043 | | | `--RPAREN -> ) [1787:67]
21044 | | |--COMMA -> , [1787:68]
21045 | | |--EXPR -> EXPR [1788:21]
21046 | | | `--PLUS -> + [1788:21]
21047 | | | |--STRING_LITERAL -> "12:1: " [1788:12]
21048 | | | `--METHOD_CALL -> ( [1788:38]
21049 | | | |--IDENT -> getCheckMessage [1788:23]
21050 | | | |--ELIST -> ELIST [1788:39]
21051 | | | | |--EXPR -> EXPR [1788:39]
21052 | | | | | `--IDENT -> MSG_ERROR [1788:39]
21053 | | | | |--COMMA -> , [1788:48]
21054 | | | | |--EXPR -> EXPR [1788:50]
21055 | | | | | `--STRING_LITERAL -> "do..while while" [1788:50]
21056 | | | | |--COMMA -> , [1788:67]
21057 | | | | |--EXPR -> EXPR [1788:69]
21058 | | | | | `--NUM_INT -> 0 [1788:69]
21059 | | | | |--COMMA -> , [1788:70]
21060 | | | | `--EXPR -> EXPR [1788:72]
21061 | | | | `--NUM_INT -> 8 [1788:72]
21062 | | | `--RPAREN -> ) [1788:73]
21063 | | |--COMMA -> , [1788:74]
21064 | | |--EXPR -> EXPR [1789:21]
21065 | | | `--PLUS -> + [1789:21]
21066 | | | |--STRING_LITERAL -> "13:1: " [1789:12]
21067 | | | `--METHOD_CALL -> ( [1789:38]
21068 | | | |--IDENT -> getCheckMessage [1789:23]
21069 | | | |--ELIST -> ELIST [1789:39]
21070 | | | | |--EXPR -> EXPR [1789:39]
21071 | | | | | `--IDENT -> MSG_ERROR [1789:39]
21072 | | | | |--COMMA -> , [1789:48]
21073 | | | | |--EXPR -> EXPR [1789:50]
21074 | | | | | `--STRING_LITERAL -> "do..while" [1789:50]
21075 | | | | |--COMMA -> , [1789:61]
21076 | | | | |--EXPR -> EXPR [1789:63]
21077 | | | | | `--NUM_INT -> 0 [1789:63]
21078 | | | | |--COMMA -> , [1789:64]
21079 | | | | `--EXPR -> EXPR [1789:66]
21080 | | | | `--NUM_INT -> 8 [1789:66]
21081 | | | `--RPAREN -> ) [1789:67]
21082 | | |--COMMA -> , [1789:68]
21083 | | |--EXPR -> EXPR [1790:21]
21084 | | | `--PLUS -> + [1790:21]
21085 | | | |--STRING_LITERAL -> "14:1: " [1790:12]
21086 | | | `--METHOD_CALL -> ( [1790:38]
21087 | | | |--IDENT -> getCheckMessage [1790:23]
21088 | | | |--ELIST -> ELIST [1790:39]
21089 | | | | |--EXPR -> EXPR [1790:39]
21090 | | | | | `--IDENT -> MSG_ERROR [1790:39]
21091 | | | | |--COMMA -> , [1790:48]
21092 | | | | |--EXPR -> EXPR [1790:50]
21093 | | | | | `--STRING_LITERAL -> "do..while lcurly" [1790:50]
21094 | | | | |--COMMA -> , [1790:68]
21095 | | | | |--EXPR -> EXPR [1790:70]
21096 | | | | | `--NUM_INT -> 0 [1790:70]
21097 | | | | |--COMMA -> , [1790:71]
21098 | | | | `--EXPR -> EXPR [1790:73]
21099 | | | | `--NUM_INT -> 8 [1790:73]
21100 | | | `--RPAREN -> ) [1790:74]
21101 | | |--COMMA -> , [1790:75]
21102 | | |--EXPR -> EXPR [1791:21]
21103 | | | `--PLUS -> + [1791:21]
21104 | | | |--STRING_LITERAL -> "15:1: " [1791:12]
21105 | | | `--METHOD_CALL -> ( [1791:38]
21106 | | | |--IDENT -> getCheckMessage [1791:23]
21107 | | | |--ELIST -> ELIST [1791:39]
21108 | | | | |--EXPR -> EXPR [1791:39]
21109 | | | | | `--IDENT -> MSG_ERROR [1791:39]
21110 | | | | |--COMMA -> , [1791:48]
21111 | | | | |--EXPR -> EXPR [1791:50]
21112 | | | | | `--STRING_LITERAL -> "do..while" [1791:50]
21113 | | | | |--COMMA -> , [1791:61]
21114 | | | | |--EXPR -> EXPR [1791:63]
21115 | | | | | `--NUM_INT -> 0 [1791:63]
21116 | | | | |--COMMA -> , [1791:64]
21117 | | | | `--EXPR -> EXPR [1791:66]
21118 | | | | `--NUM_INT -> 8 [1791:66]
21119 | | | `--RPAREN -> ) [1791:67]
21120 | | |--COMMA -> , [1791:68]
21121 | | |--EXPR -> EXPR [1792:21]
21122 | | | `--PLUS -> + [1792:21]
21123 | | | |--STRING_LITERAL -> "16:1: " [1792:12]
21124 | | | `--METHOD_CALL -> ( [1792:38]
21125 | | | |--IDENT -> getCheckMessage [1792:23]
21126 | | | |--ELIST -> ELIST [1792:39]
21127 | | | | |--EXPR -> EXPR [1792:39]
21128 | | | | | `--IDENT -> MSG_ERROR [1792:39]
21129 | | | | |--COMMA -> , [1792:48]
21130 | | | | |--EXPR -> EXPR [1792:50]
21131 | | | | | `--STRING_LITERAL -> "do..while while" [1792:50]
21132 | | | | |--COMMA -> , [1792:67]
21133 | | | | |--EXPR -> EXPR [1792:69]
21134 | | | | | `--NUM_INT -> 0 [1792:69]
21135 | | | | |--COMMA -> , [1792:70]
21136 | | | | `--EXPR -> EXPR [1792:72]
21137 | | | | `--NUM_INT -> 8 [1792:72]
21138 | | | `--RPAREN -> ) [1792:73]
21139 | | |--COMMA -> , [1792:74]
21140 | | |--EXPR -> EXPR [1793:21]
21141 | | | `--PLUS -> + [1793:21]
21142 | | | |--STRING_LITERAL -> "17:1: " [1793:12]
21143 | | | `--METHOD_CALL -> ( [1793:38]
21144 | | | |--IDENT -> getCheckMessage [1793:23]
21145 | | | |--ELIST -> ELIST [1793:39]
21146 | | | | |--EXPR -> EXPR [1793:39]
21147 | | | | | `--IDENT -> MSG_ERROR [1793:39]
21148 | | | | |--COMMA -> , [1793:48]
21149 | | | | |--EXPR -> EXPR [1793:50]
21150 | | | | | `--STRING_LITERAL -> "do..while lparen" [1793:50]
21151 | | | | |--COMMA -> , [1793:68]
21152 | | | | |--EXPR -> EXPR [1793:70]
21153 | | | | | `--NUM_INT -> 0 [1793:70]
21154 | | | | |--COMMA -> , [1793:71]
21155 | | | | `--EXPR -> EXPR [1793:73]
21156 | | | | `--NUM_INT -> 8 [1793:73]
21157 | | | `--RPAREN -> ) [1793:74]
21158 | | |--COMMA -> , [1793:75]
21159 | | |--EXPR -> EXPR [1794:21]
21160 | | | `--PLUS -> + [1794:21]
21161 | | | |--STRING_LITERAL -> "18:1: " [1794:12]
21162 | | | `--METHOD_CALL -> ( [1794:38]
21163 | | | |--IDENT -> getCheckMessage [1794:23]
21164 | | | |--ELIST -> ELIST [1794:39]
21165 | | | | |--EXPR -> EXPR [1794:39]
21166 | | | | | `--IDENT -> MSG_ERROR [1794:39]
21167 | | | | |--COMMA -> , [1794:48]
21168 | | | | |--EXPR -> EXPR [1794:50]
21169 | | | | | `--STRING_LITERAL -> "do..while" [1794:50]
21170 | | | | |--COMMA -> , [1794:61]
21171 | | | | |--EXPR -> EXPR [1794:63]
21172 | | | | | `--NUM_INT -> 0 [1794:63]
21173 | | | | |--COMMA -> , [1794:64]
21174 | | | | `--EXPR -> EXPR [1794:66]
21175 | | | | `--NUM_INT -> 8 [1794:66]
21176 | | | `--RPAREN -> ) [1794:67]
21177 | | |--COMMA -> , [1794:68]
21178 | | |--EXPR -> EXPR [1795:21]
21179 | | | `--PLUS -> + [1795:21]
21180 | | | |--STRING_LITERAL -> "19:1: " [1795:12]
21181 | | | `--METHOD_CALL -> ( [1795:38]
21182 | | | |--IDENT -> getCheckMessage [1795:23]
21183 | | | |--ELIST -> ELIST [1795:39]
21184 | | | | |--EXPR -> EXPR [1795:39]
21185 | | | | | `--IDENT -> MSG_ERROR [1795:39]
21186 | | | | |--COMMA -> , [1795:48]
21187 | | | | |--EXPR -> EXPR [1795:50]
21188 | | | | | `--STRING_LITERAL -> "do..while lparen" [1795:50]
21189 | | | | |--COMMA -> , [1795:68]
21190 | | | | |--EXPR -> EXPR [1795:70]
21191 | | | | | `--NUM_INT -> 0 [1795:70]
21192 | | | | |--COMMA -> , [1795:71]
21193 | | | | `--EXPR -> EXPR [1795:73]
21194 | | | | `--NUM_INT -> 8 [1795:73]
21195 | | | `--RPAREN -> ) [1795:74]
21196 | | |--COMMA -> , [1795:75]
21197 | | |--EXPR -> EXPR [1796:21]
21198 | | | `--PLUS -> + [1796:21]
21199 | | | |--STRING_LITERAL -> "20:1: " [1796:12]
21200 | | | `--METHOD_CALL -> ( [1796:38]
21201 | | | |--IDENT -> getCheckMessage [1796:23]
21202 | | | |--ELIST -> ELIST [1796:39]
21203 | | | | |--EXPR -> EXPR [1796:39]
21204 | | | | | `--IDENT -> MSG_ERROR [1796:39]
21205 | | | | |--COMMA -> , [1796:48]
21206 | | | | |--EXPR -> EXPR [1796:50]
21207 | | | | | `--STRING_LITERAL -> "do..while" [1796:50]
21208 | | | | |--COMMA -> , [1796:61]
21209 | | | | |--EXPR -> EXPR [1796:63]
21210 | | | | | `--NUM_INT -> 0 [1796:63]
21211 | | | | |--COMMA -> , [1796:64]
21212 | | | | `--EXPR -> EXPR [1796:66]
21213 | | | | `--NUM_INT -> 8 [1796:66]
21214 | | | `--RPAREN -> ) [1796:67]
21215 | | |--COMMA -> , [1796:68]
21216 | | |--EXPR -> EXPR [1797:21]
21217 | | | `--PLUS -> + [1797:21]
21218 | | | |--STRING_LITERAL -> "21:1: " [1797:12]
21219 | | | `--METHOD_CALL -> ( [1797:38]
21220 | | | |--IDENT -> getCheckMessage [1797:23]
21221 | | | |--ELIST -> ELIST [1797:39]
21222 | | | | |--EXPR -> EXPR [1797:39]
21223 | | | | | `--IDENT -> MSG_ERROR [1797:39]
21224 | | | | |--COMMA -> , [1797:48]
21225 | | | | |--EXPR -> EXPR [1797:50]
21226 | | | | | `--STRING_LITERAL -> "do..while lparen" [1797:50]
21227 | | | | |--COMMA -> , [1797:68]
21228 | | | | |--EXPR -> EXPR [1797:70]
21229 | | | | | `--NUM_INT -> 0 [1797:70]
21230 | | | | |--COMMA -> , [1797:71]
21231 | | | | `--EXPR -> EXPR [1797:73]
21232 | | | | `--NUM_INT -> 8 [1797:73]
21233 | | | `--RPAREN -> ) [1797:74]
21234 | | |--COMMA -> , [1797:75]
21235 | | |--EXPR -> EXPR [1798:21]
21236 | | | `--PLUS -> + [1798:21]
21237 | | | |--STRING_LITERAL -> "22:1: " [1798:12]
21238 | | | `--METHOD_CALL -> ( [1798:38]
21239 | | | |--IDENT -> getCheckMessage [1798:23]
21240 | | | |--ELIST -> ELIST [1798:39]
21241 | | | | |--EXPR -> EXPR [1798:39]
21242 | | | | | `--IDENT -> MSG_CHILD_ERROR [1798:39]
21243 | | | | |--COMMA -> , [1798:54]
21244 | | | | |--EXPR -> EXPR [1798:56]
21245 | | | | | `--STRING_LITERAL -> "do..while" [1798:56]
21246 | | | | |--COMMA -> , [1798:67]
21247 | | | | |--EXPR -> EXPR [1798:69]
21248 | | | | | `--NUM_INT -> 0 [1798:69]
21249 | | | | |--COMMA -> , [1798:70]
21250 | | | | `--EXPR -> EXPR [1798:72]
21251 | | | | `--NUM_INT -> 8 [1798:72]
21252 | | | `--RPAREN -> ) [1798:73]
21253 | | |--COMMA -> , [1798:74]
21254 | | |--EXPR -> EXPR [1799:21]
21255 | | | `--PLUS -> + [1799:21]
21256 | | | |--STRING_LITERAL -> "23:1: " [1799:12]
21257 | | | `--METHOD_CALL -> ( [1799:38]
21258 | | | |--IDENT -> getCheckMessage [1799:23]
21259 | | | |--ELIST -> ELIST [1799:39]
21260 | | | | |--EXPR -> EXPR [1799:39]
21261 | | | | | `--IDENT -> MSG_ERROR [1799:39]
21262 | | | | |--COMMA -> , [1799:48]
21263 | | | | |--EXPR -> EXPR [1799:50]
21264 | | | | | `--STRING_LITERAL -> "do..while rparen" [1799:50]
21265 | | | | |--COMMA -> , [1799:68]
21266 | | | | |--EXPR -> EXPR [1799:70]
21267 | | | | | `--NUM_INT -> 0 [1799:70]
21268 | | | | |--COMMA -> , [1799:71]
21269 | | | | `--EXPR -> EXPR [1799:73]
21270 | | | | `--NUM_INT -> 8 [1799:73]
21271 | | | `--RPAREN -> ) [1799:74]
21272 | | |--COMMA -> , [1799:75]
21273 | | `--RCURLY -> } [1800:8]
21274 | |--SEMI -> ; [1800:9]
21275 | |--EXPR -> EXPR [1801:19]
21276 | | `--METHOD_CALL -> ( [1801:19]
21277 | | |--IDENT -> verifyWarns [1801:8]
21278 | | |--ELIST -> ELIST [1801:20]
21279 | | | |--EXPR -> EXPR [1801:20]
21280 | | | | `--IDENT -> checkConfig [1801:20]
21281 | | | |--COMMA -> , [1801:31]
21282 | | | |--EXPR -> EXPR [1801:33]
21283 | | | | `--IDENT -> fileName [1801:33]
21284 | | | |--COMMA -> , [1801:41]
21285 | | | `--EXPR -> EXPR [1801:43]
21286 | | | `--IDENT -> expected [1801:43]
21287 | | `--RPAREN -> ) [1801:51]
21288 | |--SEMI -> ; [1801:52]
21289 | `--RCURLY -> } [1802:4]
21290 |--METHOD_DEF -> METHOD_DEF [1804:4]
21291 | |--MODIFIERS -> MODIFIERS [1804:4]
21292 | | |--ANNOTATION -> ANNOTATION [1804:4]
21293 | | | |--AT -> @ [1804:4]
21294 | | | `--IDENT -> Test [1804:5]
21295 | | `--LITERAL_PUBLIC -> public [1805:4]
21296 | |--TYPE -> TYPE [1805:11]
21297 | | `--LITERAL_VOID -> void [1805:11]
21298 | |--IDENT -> testValidBlockWithChecker [1805:16]
21299 | |--LPAREN -> ( [1805:41]
21300 | |--PARAMETERS -> PARAMETERS [1805:42]
21301 | |--RPAREN -> ) [1805:42]
21302 | |--LITERAL_THROWS -> throws [1806:12]
21303 | | `--IDENT -> Exception [1806:19]
21304 | `--SLIST -> { [1806:29]
21305 | |--VARIABLE_DEF -> VARIABLE_DEF [1807:8]
21306 | | |--MODIFIERS -> MODIFIERS [1807:8]
21307 | | | `--FINAL -> final [1807:8]
21308 | | |--TYPE -> TYPE [1807:14]
21309 | | | `--IDENT -> DefaultConfiguration [1807:14]
21310 | | |--IDENT -> checkConfig [1807:35]
21311 | | `--ASSIGN -> = [1807:47]
21312 | | `--EXPR -> EXPR [1807:67]
21313 | | `--METHOD_CALL -> ( [1807:67]
21314 | | |--IDENT -> createModuleConfig [1807:49]
21315 | | |--ELIST -> ELIST [1807:84]
21316 | | | `--EXPR -> EXPR [1807:84]
21317 | | | `--DOT -> . [1807:84]
21318 | | | |--IDENT -> IndentationCheck [1807:68]
21319 | | | `--LITERAL_CLASS -> class [1807:85]
21320 | | `--RPAREN -> ) [1807:90]
21321 | |--SEMI -> ; [1807:91]
21322 | |--EXPR -> EXPR [1809:32]
21323 | | `--METHOD_CALL -> ( [1809:32]
21324 | | |--DOT -> . [1809:19]
21325 | | | |--IDENT -> checkConfig [1809:8]
21326 | | | `--IDENT -> addAttribute [1809:20]
21327 | | |--ELIST -> ELIST [1809:33]
21328 | | | |--EXPR -> EXPR [1809:33]
21329 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1809:33]
21330 | | | |--COMMA -> , [1809:50]
21331 | | | `--EXPR -> EXPR [1809:52]
21332 | | | `--STRING_LITERAL -> "4" [1809:52]
21333 | | `--RPAREN -> ) [1809:55]
21334 | |--SEMI -> ; [1809:56]
21335 | |--EXPR -> EXPR [1810:32]
21336 | | `--METHOD_CALL -> ( [1810:32]
21337 | | |--DOT -> . [1810:19]
21338 | | | |--IDENT -> checkConfig [1810:8]
21339 | | | `--IDENT -> addAttribute [1810:20]
21340 | | |--ELIST -> ELIST [1810:33]
21341 | | | |--EXPR -> EXPR [1810:33]
21342 | | | | `--STRING_LITERAL -> "basicOffset" [1810:33]
21343 | | | |--COMMA -> , [1810:46]
21344 | | | `--EXPR -> EXPR [1810:48]
21345 | | | `--STRING_LITERAL -> "4" [1810:48]
21346 | | `--RPAREN -> ) [1810:51]
21347 | |--SEMI -> ; [1810:52]
21348 | |--EXPR -> EXPR [1811:32]
21349 | | `--METHOD_CALL -> ( [1811:32]
21350 | | |--DOT -> . [1811:19]
21351 | | | |--IDENT -> checkConfig [1811:8]
21352 | | | `--IDENT -> addAttribute [1811:20]
21353 | | |--ELIST -> ELIST [1811:33]
21354 | | | |--EXPR -> EXPR [1811:33]
21355 | | | | `--STRING_LITERAL -> "braceAdjustment" [1811:33]
21356 | | | |--COMMA -> , [1811:50]
21357 | | | `--EXPR -> EXPR [1811:52]
21358 | | | `--STRING_LITERAL -> "0" [1811:52]
21359 | | `--RPAREN -> ) [1811:55]
21360 | |--SEMI -> ; [1811:56]
21361 | |--EXPR -> EXPR [1812:32]
21362 | | `--METHOD_CALL -> ( [1812:32]
21363 | | |--DOT -> . [1812:19]
21364 | | | |--IDENT -> checkConfig [1812:8]
21365 | | | `--IDENT -> addAttribute [1812:20]
21366 | | |--ELIST -> ELIST [1812:33]
21367 | | | |--EXPR -> EXPR [1812:33]
21368 | | | | `--STRING_LITERAL -> "caseIndent" [1812:33]
21369 | | | |--COMMA -> , [1812:45]
21370 | | | `--EXPR -> EXPR [1812:47]
21371 | | | `--STRING_LITERAL -> "4" [1812:47]
21372 | | `--RPAREN -> ) [1812:50]
21373 | |--SEMI -> ; [1812:51]
21374 | |--EXPR -> EXPR [1813:32]
21375 | | `--METHOD_CALL -> ( [1813:32]
21376 | | |--DOT -> . [1813:19]
21377 | | | |--IDENT -> checkConfig [1813:8]
21378 | | | `--IDENT -> addAttribute [1813:20]
21379 | | |--ELIST -> ELIST [1813:33]
21380 | | | |--EXPR -> EXPR [1813:33]
21381 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1813:33]
21382 | | | |--COMMA -> , [1813:55]
21383 | | | `--EXPR -> EXPR [1813:57]
21384 | | | `--STRING_LITERAL -> "false" [1813:57]
21385 | | `--RPAREN -> ) [1813:64]
21386 | |--SEMI -> ; [1813:65]
21387 | |--EXPR -> EXPR [1814:32]
21388 | | `--METHOD_CALL -> ( [1814:32]
21389 | | |--DOT -> . [1814:19]
21390 | | | |--IDENT -> checkConfig [1814:8]
21391 | | | `--IDENT -> addAttribute [1814:20]
21392 | | |--ELIST -> ELIST [1814:33]
21393 | | | |--EXPR -> EXPR [1814:33]
21394 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1814:33]
21395 | | | |--COMMA -> , [1814:58]
21396 | | | `--EXPR -> EXPR [1814:60]
21397 | | | `--STRING_LITERAL -> "4" [1814:60]
21398 | | `--RPAREN -> ) [1814:63]
21399 | |--SEMI -> ; [1814:64]
21400 | |--EXPR -> EXPR [1815:32]
21401 | | `--METHOD_CALL -> ( [1815:32]
21402 | | |--DOT -> . [1815:19]
21403 | | | |--IDENT -> checkConfig [1815:8]
21404 | | | `--IDENT -> addAttribute [1815:20]
21405 | | |--ELIST -> ELIST [1815:33]
21406 | | | |--EXPR -> EXPR [1815:33]
21407 | | | | `--STRING_LITERAL -> "tabWidth" [1815:33]
21408 | | | |--COMMA -> , [1815:43]
21409 | | | `--EXPR -> EXPR [1815:45]
21410 | | | `--STRING_LITERAL -> "4" [1815:45]
21411 | | `--RPAREN -> ) [1815:48]
21412 | |--SEMI -> ; [1815:49]
21413 | |--EXPR -> EXPR [1816:32]
21414 | | `--METHOD_CALL -> ( [1816:32]
21415 | | |--DOT -> . [1816:19]
21416 | | | |--IDENT -> checkConfig [1816:8]
21417 | | | `--IDENT -> addAttribute [1816:20]
21418 | | |--ELIST -> ELIST [1816:33]
21419 | | | |--EXPR -> EXPR [1816:33]
21420 | | | | `--STRING_LITERAL -> "throwsIndent" [1816:33]
21421 | | | |--COMMA -> , [1816:47]
21422 | | | `--EXPR -> EXPR [1816:49]
21423 | | | `--STRING_LITERAL -> "4" [1816:49]
21424 | | `--RPAREN -> ) [1816:52]
21425 | |--SEMI -> ; [1816:53]
21426 | |--VARIABLE_DEF -> VARIABLE_DEF [1817:8]
21427 | | |--MODIFIERS -> MODIFIERS [1817:8]
21428 | | | `--FINAL -> final [1817:8]
21429 | | |--TYPE -> TYPE [1817:14]
21430 | | | `--IDENT -> String [1817:14]
21431 | | |--IDENT -> fileName [1817:21]
21432 | | `--ASSIGN -> = [1817:30]
21433 | | `--EXPR -> EXPR [1817:39]
21434 | | `--METHOD_CALL -> ( [1817:39]
21435 | | |--IDENT -> getPath [1817:32]
21436 | | |--ELIST -> ELIST [1817:40]
21437 | | | `--EXPR -> EXPR [1817:40]
21438 | | | `--STRING_LITERAL -> "InputIndentationValidBlockIndent.java" [1817:40]
21439 | | `--RPAREN -> ) [1817:79]
21440 | |--SEMI -> ; [1817:80]
21441 | |--VARIABLE_DEF -> VARIABLE_DEF [1818:8]
21442 | | |--MODIFIERS -> MODIFIERS [1818:8]
21443 | | | `--FINAL -> final [1818:8]
21444 | | |--TYPE -> TYPE [1818:20]
21445 | | | `--ARRAY_DECLARATOR -> [ [1818:20]
21446 | | | |--IDENT -> String [1818:14]
21447 | | | `--RBRACK -> ] [1818:21]
21448 | | |--IDENT -> expected [1818:23]
21449 | | `--ASSIGN -> = [1818:32]
21450 | | `--EXPR -> EXPR [1818:44]
21451 | | `--DOT -> . [1818:44]
21452 | | |--IDENT -> CommonUtil [1818:34]
21453 | | `--IDENT -> EMPTY_STRING_ARRAY [1818:45]
21454 | |--SEMI -> ; [1818:63]
21455 | |--EXPR -> EXPR [1819:19]
21456 | | `--METHOD_CALL -> ( [1819:19]
21457 | | |--IDENT -> verifyWarns [1819:8]
21458 | | |--ELIST -> ELIST [1819:20]
21459 | | | |--EXPR -> EXPR [1819:20]
21460 | | | | `--IDENT -> checkConfig [1819:20]
21461 | | | |--COMMA -> , [1819:31]
21462 | | | |--EXPR -> EXPR [1819:33]
21463 | | | | `--IDENT -> fileName [1819:33]
21464 | | | |--COMMA -> , [1819:41]
21465 | | | `--EXPR -> EXPR [1819:43]
21466 | | | `--IDENT -> expected [1819:43]
21467 | | `--RPAREN -> ) [1819:51]
21468 | |--SEMI -> ; [1819:52]
21469 | `--RCURLY -> } [1820:4]
21470 |--METHOD_DEF -> METHOD_DEF [1822:4]
21471 | |--MODIFIERS -> MODIFIERS [1822:4]
21472 | | |--ANNOTATION -> ANNOTATION [1822:4]
21473 | | | |--AT -> @ [1822:4]
21474 | | | `--IDENT -> Test [1822:5]
21475 | | `--LITERAL_PUBLIC -> public [1823:4]
21476 | |--TYPE -> TYPE [1823:11]
21477 | | `--LITERAL_VOID -> void [1823:11]
21478 | |--IDENT -> testValidWhileWithChecker [1823:16]
21479 | |--LPAREN -> ( [1823:41]
21480 | |--PARAMETERS -> PARAMETERS [1823:42]
21481 | |--RPAREN -> ) [1823:42]
21482 | |--LITERAL_THROWS -> throws [1824:12]
21483 | | `--IDENT -> Exception [1824:19]
21484 | `--SLIST -> { [1824:29]
21485 | |--VARIABLE_DEF -> VARIABLE_DEF [1825:8]
21486 | | |--MODIFIERS -> MODIFIERS [1825:8]
21487 | | | `--FINAL -> final [1825:8]
21488 | | |--TYPE -> TYPE [1825:14]
21489 | | | `--IDENT -> DefaultConfiguration [1825:14]
21490 | | |--IDENT -> checkConfig [1825:35]
21491 | | `--ASSIGN -> = [1825:47]
21492 | | `--EXPR -> EXPR [1825:67]
21493 | | `--METHOD_CALL -> ( [1825:67]
21494 | | |--IDENT -> createModuleConfig [1825:49]
21495 | | |--ELIST -> ELIST [1825:84]
21496 | | | `--EXPR -> EXPR [1825:84]
21497 | | | `--DOT -> . [1825:84]
21498 | | | |--IDENT -> IndentationCheck [1825:68]
21499 | | | `--LITERAL_CLASS -> class [1825:85]
21500 | | `--RPAREN -> ) [1825:90]
21501 | |--SEMI -> ; [1825:91]
21502 | |--EXPR -> EXPR [1827:32]
21503 | | `--METHOD_CALL -> ( [1827:32]
21504 | | |--DOT -> . [1827:19]
21505 | | | |--IDENT -> checkConfig [1827:8]
21506 | | | `--IDENT -> addAttribute [1827:20]
21507 | | |--ELIST -> ELIST [1827:33]
21508 | | | |--EXPR -> EXPR [1827:33]
21509 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1827:33]
21510 | | | |--COMMA -> , [1827:50]
21511 | | | `--EXPR -> EXPR [1827:52]
21512 | | | `--STRING_LITERAL -> "4" [1827:52]
21513 | | `--RPAREN -> ) [1827:55]
21514 | |--SEMI -> ; [1827:56]
21515 | |--EXPR -> EXPR [1828:32]
21516 | | `--METHOD_CALL -> ( [1828:32]
21517 | | |--DOT -> . [1828:19]
21518 | | | |--IDENT -> checkConfig [1828:8]
21519 | | | `--IDENT -> addAttribute [1828:20]
21520 | | |--ELIST -> ELIST [1828:33]
21521 | | | |--EXPR -> EXPR [1828:33]
21522 | | | | `--STRING_LITERAL -> "basicOffset" [1828:33]
21523 | | | |--COMMA -> , [1828:46]
21524 | | | `--EXPR -> EXPR [1828:48]
21525 | | | `--STRING_LITERAL -> "4" [1828:48]
21526 | | `--RPAREN -> ) [1828:51]
21527 | |--SEMI -> ; [1828:52]
21528 | |--EXPR -> EXPR [1829:32]
21529 | | `--METHOD_CALL -> ( [1829:32]
21530 | | |--DOT -> . [1829:19]
21531 | | | |--IDENT -> checkConfig [1829:8]
21532 | | | `--IDENT -> addAttribute [1829:20]
21533 | | |--ELIST -> ELIST [1829:33]
21534 | | | |--EXPR -> EXPR [1829:33]
21535 | | | | `--STRING_LITERAL -> "braceAdjustment" [1829:33]
21536 | | | |--COMMA -> , [1829:50]
21537 | | | `--EXPR -> EXPR [1829:52]
21538 | | | `--STRING_LITERAL -> "0" [1829:52]
21539 | | `--RPAREN -> ) [1829:55]
21540 | |--SEMI -> ; [1829:56]
21541 | |--EXPR -> EXPR [1830:32]
21542 | | `--METHOD_CALL -> ( [1830:32]
21543 | | |--DOT -> . [1830:19]
21544 | | | |--IDENT -> checkConfig [1830:8]
21545 | | | `--IDENT -> addAttribute [1830:20]
21546 | | |--ELIST -> ELIST [1830:33]
21547 | | | |--EXPR -> EXPR [1830:33]
21548 | | | | `--STRING_LITERAL -> "caseIndent" [1830:33]
21549 | | | |--COMMA -> , [1830:45]
21550 | | | `--EXPR -> EXPR [1830:47]
21551 | | | `--STRING_LITERAL -> "4" [1830:47]
21552 | | `--RPAREN -> ) [1830:50]
21553 | |--SEMI -> ; [1830:51]
21554 | |--EXPR -> EXPR [1831:32]
21555 | | `--METHOD_CALL -> ( [1831:32]
21556 | | |--DOT -> . [1831:19]
21557 | | | |--IDENT -> checkConfig [1831:8]
21558 | | | `--IDENT -> addAttribute [1831:20]
21559 | | |--ELIST -> ELIST [1831:33]
21560 | | | |--EXPR -> EXPR [1831:33]
21561 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1831:33]
21562 | | | |--COMMA -> , [1831:55]
21563 | | | `--EXPR -> EXPR [1831:57]
21564 | | | `--STRING_LITERAL -> "false" [1831:57]
21565 | | `--RPAREN -> ) [1831:64]
21566 | |--SEMI -> ; [1831:65]
21567 | |--EXPR -> EXPR [1832:32]
21568 | | `--METHOD_CALL -> ( [1832:32]
21569 | | |--DOT -> . [1832:19]
21570 | | | |--IDENT -> checkConfig [1832:8]
21571 | | | `--IDENT -> addAttribute [1832:20]
21572 | | |--ELIST -> ELIST [1832:33]
21573 | | | |--EXPR -> EXPR [1832:33]
21574 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1832:33]
21575 | | | |--COMMA -> , [1832:58]
21576 | | | `--EXPR -> EXPR [1832:60]
21577 | | | `--STRING_LITERAL -> "4" [1832:60]
21578 | | `--RPAREN -> ) [1832:63]
21579 | |--SEMI -> ; [1832:64]
21580 | |--EXPR -> EXPR [1833:32]
21581 | | `--METHOD_CALL -> ( [1833:32]
21582 | | |--DOT -> . [1833:19]
21583 | | | |--IDENT -> checkConfig [1833:8]
21584 | | | `--IDENT -> addAttribute [1833:20]
21585 | | |--ELIST -> ELIST [1833:33]
21586 | | | |--EXPR -> EXPR [1833:33]
21587 | | | | `--STRING_LITERAL -> "tabWidth" [1833:33]
21588 | | | |--COMMA -> , [1833:43]
21589 | | | `--EXPR -> EXPR [1833:45]
21590 | | | `--STRING_LITERAL -> "4" [1833:45]
21591 | | `--RPAREN -> ) [1833:48]
21592 | |--SEMI -> ; [1833:49]
21593 | |--EXPR -> EXPR [1834:32]
21594 | | `--METHOD_CALL -> ( [1834:32]
21595 | | |--DOT -> . [1834:19]
21596 | | | |--IDENT -> checkConfig [1834:8]
21597 | | | `--IDENT -> addAttribute [1834:20]
21598 | | |--ELIST -> ELIST [1834:33]
21599 | | | |--EXPR -> EXPR [1834:33]
21600 | | | | `--STRING_LITERAL -> "throwsIndent" [1834:33]
21601 | | | |--COMMA -> , [1834:47]
21602 | | | `--EXPR -> EXPR [1834:49]
21603 | | | `--STRING_LITERAL -> "4" [1834:49]
21604 | | `--RPAREN -> ) [1834:52]
21605 | |--SEMI -> ; [1834:53]
21606 | |--VARIABLE_DEF -> VARIABLE_DEF [1835:8]
21607 | | |--MODIFIERS -> MODIFIERS [1835:8]
21608 | | | `--FINAL -> final [1835:8]
21609 | | |--TYPE -> TYPE [1835:14]
21610 | | | `--IDENT -> String [1835:14]
21611 | | |--IDENT -> fileName [1835:21]
21612 | | `--ASSIGN -> = [1835:30]
21613 | | `--EXPR -> EXPR [1835:39]
21614 | | `--METHOD_CALL -> ( [1835:39]
21615 | | |--IDENT -> getPath [1835:32]
21616 | | |--ELIST -> ELIST [1835:40]
21617 | | | `--EXPR -> EXPR [1835:40]
21618 | | | `--STRING_LITERAL -> "InputIndentationValidWhileIndent.java" [1835:40]
21619 | | `--RPAREN -> ) [1835:79]
21620 | |--SEMI -> ; [1835:80]
21621 | |--VARIABLE_DEF -> VARIABLE_DEF [1836:8]
21622 | | |--MODIFIERS -> MODIFIERS [1836:8]
21623 | | | `--FINAL -> final [1836:8]
21624 | | |--TYPE -> TYPE [1836:20]
21625 | | | `--ARRAY_DECLARATOR -> [ [1836:20]
21626 | | | |--IDENT -> String [1836:14]
21627 | | | `--RBRACK -> ] [1836:21]
21628 | | |--IDENT -> expected [1836:23]
21629 | | `--ASSIGN -> = [1836:32]
21630 | | `--EXPR -> EXPR [1836:44]
21631 | | `--DOT -> . [1836:44]
21632 | | |--IDENT -> CommonUtil [1836:34]
21633 | | `--IDENT -> EMPTY_STRING_ARRAY [1836:45]
21634 | |--SEMI -> ; [1836:63]
21635 | |--EXPR -> EXPR [1837:19]
21636 | | `--METHOD_CALL -> ( [1837:19]
21637 | | |--IDENT -> verifyWarns [1837:8]
21638 | | |--ELIST -> ELIST [1837:20]
21639 | | | |--EXPR -> EXPR [1837:20]
21640 | | | | `--IDENT -> checkConfig [1837:20]
21641 | | | |--COMMA -> , [1837:31]
21642 | | | |--EXPR -> EXPR [1837:33]
21643 | | | | `--IDENT -> fileName [1837:33]
21644 | | | |--COMMA -> , [1837:41]
21645 | | | `--EXPR -> EXPR [1837:43]
21646 | | | `--IDENT -> expected [1837:43]
21647 | | `--RPAREN -> ) [1837:51]
21648 | |--SEMI -> ; [1837:52]
21649 | `--RCURLY -> } [1838:4]
21650 |--METHOD_DEF -> METHOD_DEF [1840:4]
21651 | |--MODIFIERS -> MODIFIERS [1840:4]
21652 | | |--ANNOTATION -> ANNOTATION [1840:4]
21653 | | | |--AT -> @ [1840:4]
21654 | | | `--IDENT -> Test [1840:5]
21655 | | `--LITERAL_PUBLIC -> public [1841:4]
21656 | |--TYPE -> TYPE [1841:11]
21657 | | `--LITERAL_VOID -> void [1841:11]
21658 | |--IDENT -> testValidClassDefWithChecker [1841:16]
21659 | |--LPAREN -> ( [1841:44]
21660 | |--PARAMETERS -> PARAMETERS [1841:45]
21661 | |--RPAREN -> ) [1841:45]
21662 | |--LITERAL_THROWS -> throws [1842:12]
21663 | | `--IDENT -> Exception [1842:19]
21664 | `--SLIST -> { [1842:29]
21665 | |--VARIABLE_DEF -> VARIABLE_DEF [1843:8]
21666 | | |--MODIFIERS -> MODIFIERS [1843:8]
21667 | | | `--FINAL -> final [1843:8]
21668 | | |--TYPE -> TYPE [1843:14]
21669 | | | `--IDENT -> DefaultConfiguration [1843:14]
21670 | | |--IDENT -> checkConfig [1843:35]
21671 | | `--ASSIGN -> = [1843:47]
21672 | | `--EXPR -> EXPR [1843:67]
21673 | | `--METHOD_CALL -> ( [1843:67]
21674 | | |--IDENT -> createModuleConfig [1843:49]
21675 | | |--ELIST -> ELIST [1843:84]
21676 | | | `--EXPR -> EXPR [1843:84]
21677 | | | `--DOT -> . [1843:84]
21678 | | | |--IDENT -> IndentationCheck [1843:68]
21679 | | | `--LITERAL_CLASS -> class [1843:85]
21680 | | `--RPAREN -> ) [1843:90]
21681 | |--SEMI -> ; [1843:91]
21682 | |--EXPR -> EXPR [1845:32]
21683 | | `--METHOD_CALL -> ( [1845:32]
21684 | | |--DOT -> . [1845:19]
21685 | | | |--IDENT -> checkConfig [1845:8]
21686 | | | `--IDENT -> addAttribute [1845:20]
21687 | | |--ELIST -> ELIST [1845:33]
21688 | | | |--EXPR -> EXPR [1845:33]
21689 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1845:33]
21690 | | | |--COMMA -> , [1845:50]
21691 | | | `--EXPR -> EXPR [1845:52]
21692 | | | `--STRING_LITERAL -> "4" [1845:52]
21693 | | `--RPAREN -> ) [1845:55]
21694 | |--SEMI -> ; [1845:56]
21695 | |--EXPR -> EXPR [1846:32]
21696 | | `--METHOD_CALL -> ( [1846:32]
21697 | | |--DOT -> . [1846:19]
21698 | | | |--IDENT -> checkConfig [1846:8]
21699 | | | `--IDENT -> addAttribute [1846:20]
21700 | | |--ELIST -> ELIST [1846:33]
21701 | | | |--EXPR -> EXPR [1846:33]
21702 | | | | `--STRING_LITERAL -> "basicOffset" [1846:33]
21703 | | | |--COMMA -> , [1846:46]
21704 | | | `--EXPR -> EXPR [1846:48]
21705 | | | `--STRING_LITERAL -> "4" [1846:48]
21706 | | `--RPAREN -> ) [1846:51]
21707 | |--SEMI -> ; [1846:52]
21708 | |--EXPR -> EXPR [1847:32]
21709 | | `--METHOD_CALL -> ( [1847:32]
21710 | | |--DOT -> . [1847:19]
21711 | | | |--IDENT -> checkConfig [1847:8]
21712 | | | `--IDENT -> addAttribute [1847:20]
21713 | | |--ELIST -> ELIST [1847:33]
21714 | | | |--EXPR -> EXPR [1847:33]
21715 | | | | `--STRING_LITERAL -> "braceAdjustment" [1847:33]
21716 | | | |--COMMA -> , [1847:50]
21717 | | | `--EXPR -> EXPR [1847:52]
21718 | | | `--STRING_LITERAL -> "0" [1847:52]
21719 | | `--RPAREN -> ) [1847:55]
21720 | |--SEMI -> ; [1847:56]
21721 | |--EXPR -> EXPR [1848:32]
21722 | | `--METHOD_CALL -> ( [1848:32]
21723 | | |--DOT -> . [1848:19]
21724 | | | |--IDENT -> checkConfig [1848:8]
21725 | | | `--IDENT -> addAttribute [1848:20]
21726 | | |--ELIST -> ELIST [1848:33]
21727 | | | |--EXPR -> EXPR [1848:33]
21728 | | | | `--STRING_LITERAL -> "caseIndent" [1848:33]
21729 | | | |--COMMA -> , [1848:45]
21730 | | | `--EXPR -> EXPR [1848:47]
21731 | | | `--STRING_LITERAL -> "4" [1848:47]
21732 | | `--RPAREN -> ) [1848:50]
21733 | |--SEMI -> ; [1848:51]
21734 | |--EXPR -> EXPR [1849:32]
21735 | | `--METHOD_CALL -> ( [1849:32]
21736 | | |--DOT -> . [1849:19]
21737 | | | |--IDENT -> checkConfig [1849:8]
21738 | | | `--IDENT -> addAttribute [1849:20]
21739 | | |--ELIST -> ELIST [1849:33]
21740 | | | |--EXPR -> EXPR [1849:33]
21741 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1849:33]
21742 | | | |--COMMA -> , [1849:55]
21743 | | | `--EXPR -> EXPR [1849:57]
21744 | | | `--STRING_LITERAL -> "false" [1849:57]
21745 | | `--RPAREN -> ) [1849:64]
21746 | |--SEMI -> ; [1849:65]
21747 | |--EXPR -> EXPR [1850:32]
21748 | | `--METHOD_CALL -> ( [1850:32]
21749 | | |--DOT -> . [1850:19]
21750 | | | |--IDENT -> checkConfig [1850:8]
21751 | | | `--IDENT -> addAttribute [1850:20]
21752 | | |--ELIST -> ELIST [1850:33]
21753 | | | |--EXPR -> EXPR [1850:33]
21754 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1850:33]
21755 | | | |--COMMA -> , [1850:58]
21756 | | | `--EXPR -> EXPR [1850:60]
21757 | | | `--STRING_LITERAL -> "4" [1850:60]
21758 | | `--RPAREN -> ) [1850:63]
21759 | |--SEMI -> ; [1850:64]
21760 | |--EXPR -> EXPR [1851:32]
21761 | | `--METHOD_CALL -> ( [1851:32]
21762 | | |--DOT -> . [1851:19]
21763 | | | |--IDENT -> checkConfig [1851:8]
21764 | | | `--IDENT -> addAttribute [1851:20]
21765 | | |--ELIST -> ELIST [1851:33]
21766 | | | |--EXPR -> EXPR [1851:33]
21767 | | | | `--STRING_LITERAL -> "tabWidth" [1851:33]
21768 | | | |--COMMA -> , [1851:43]
21769 | | | `--EXPR -> EXPR [1851:45]
21770 | | | `--STRING_LITERAL -> "4" [1851:45]
21771 | | `--RPAREN -> ) [1851:48]
21772 | |--SEMI -> ; [1851:49]
21773 | |--EXPR -> EXPR [1852:32]
21774 | | `--METHOD_CALL -> ( [1852:32]
21775 | | |--DOT -> . [1852:19]
21776 | | | |--IDENT -> checkConfig [1852:8]
21777 | | | `--IDENT -> addAttribute [1852:20]
21778 | | |--ELIST -> ELIST [1852:33]
21779 | | | |--EXPR -> EXPR [1852:33]
21780 | | | | `--STRING_LITERAL -> "throwsIndent" [1852:33]
21781 | | | |--COMMA -> , [1852:47]
21782 | | | `--EXPR -> EXPR [1852:49]
21783 | | | `--STRING_LITERAL -> "4" [1852:49]
21784 | | `--RPAREN -> ) [1852:52]
21785 | |--SEMI -> ; [1852:53]
21786 | |--VARIABLE_DEF -> VARIABLE_DEF [1853:8]
21787 | | |--MODIFIERS -> MODIFIERS [1853:8]
21788 | | | `--FINAL -> final [1853:8]
21789 | | |--TYPE -> TYPE [1853:14]
21790 | | | `--IDENT -> String [1853:14]
21791 | | |--IDENT -> fileName [1853:21]
21792 | | `--ASSIGN -> = [1853:30]
21793 | | `--EXPR -> EXPR [1853:39]
21794 | | `--METHOD_CALL -> ( [1853:39]
21795 | | |--IDENT -> getPath [1853:32]
21796 | | |--ELIST -> ELIST [1853:40]
21797 | | | `--EXPR -> EXPR [1853:40]
21798 | | | `--STRING_LITERAL -> "InputIndentationValidClassDefIndent.java" [1853:40]
21799 | | `--RPAREN -> ) [1853:82]
21800 | |--SEMI -> ; [1853:83]
21801 | |--VARIABLE_DEF -> VARIABLE_DEF [1854:8]
21802 | | |--MODIFIERS -> MODIFIERS [1854:8]
21803 | | | `--FINAL -> final [1854:8]
21804 | | |--TYPE -> TYPE [1854:20]
21805 | | | `--ARRAY_DECLARATOR -> [ [1854:20]
21806 | | | |--IDENT -> String [1854:14]
21807 | | | `--RBRACK -> ] [1854:21]
21808 | | |--IDENT -> expected [1854:23]
21809 | | `--ASSIGN -> = [1854:32]
21810 | | `--ARRAY_INIT -> { [1854:34]
21811 | | |--EXPR -> EXPR [1855:21]
21812 | | | `--PLUS -> + [1855:21]
21813 | | | |--STRING_LITERAL -> "49:1: " [1855:12]
21814 | | | `--METHOD_CALL -> ( [1855:38]
21815 | | | |--IDENT -> getCheckMessage [1855:23]
21816 | | | |--ELIST -> ELIST [1855:39]
21817 | | | | |--EXPR -> EXPR [1855:39]
21818 | | | | | `--IDENT -> MSG_ERROR [1855:39]
21819 | | | | |--COMMA -> , [1855:48]
21820 | | | | |--EXPR -> EXPR [1855:50]
21821 | | | | | `--STRING_LITERAL -> "class" [1855:50]
21822 | | | | |--COMMA -> , [1855:57]
21823 | | | | |--EXPR -> EXPR [1855:59]
21824 | | | | | `--NUM_INT -> 0 [1855:59]
21825 | | | | |--COMMA -> , [1855:60]
21826 | | | | `--EXPR -> EXPR [1855:62]
21827 | | | | `--NUM_INT -> 4 [1855:62]
21828 | | | `--RPAREN -> ) [1855:63]
21829 | | |--COMMA -> , [1855:64]
21830 | | |--EXPR -> EXPR [1856:21]
21831 | | | `--PLUS -> + [1856:21]
21832 | | | |--STRING_LITERAL -> "71:9: " [1856:12]
21833 | | | `--METHOD_CALL -> ( [1856:38]
21834 | | | |--IDENT -> getCheckMessage [1856:23]
21835 | | | |--ELIST -> ELIST [1856:39]
21836 | | | | |--EXPR -> EXPR [1856:39]
21837 | | | | | `--IDENT -> MSG_ERROR [1856:39]
21838 | | | | |--COMMA -> , [1856:48]
21839 | | | | |--EXPR -> EXPR [1856:50]
21840 | | | | | `--STRING_LITERAL -> "int" [1856:50]
21841 | | | | |--COMMA -> , [1856:55]
21842 | | | | |--EXPR -> EXPR [1856:57]
21843 | | | | | `--NUM_INT -> 8 [1856:57]
21844 | | | | |--COMMA -> , [1856:58]
21845 | | | | `--EXPR -> EXPR [1856:60]
21846 | | | | `--NUM_INT -> 12 [1856:60]
21847 | | | `--RPAREN -> ) [1856:62]
21848 | | |--COMMA -> , [1856:63]
21849 | | `--RCURLY -> } [1857:8]
21850 | |--SEMI -> ; [1857:9]
21851 | |--EXPR -> EXPR [1858:19]
21852 | | `--METHOD_CALL -> ( [1858:19]
21853 | | |--IDENT -> verifyWarns [1858:8]
21854 | | |--ELIST -> ELIST [1858:20]
21855 | | | |--EXPR -> EXPR [1858:20]
21856 | | | | `--IDENT -> checkConfig [1858:20]
21857 | | | |--COMMA -> , [1858:31]
21858 | | | |--EXPR -> EXPR [1858:33]
21859 | | | | `--IDENT -> fileName [1858:33]
21860 | | | |--COMMA -> , [1858:41]
21861 | | | `--EXPR -> EXPR [1858:43]
21862 | | | `--IDENT -> expected [1858:43]
21863 | | `--RPAREN -> ) [1858:51]
21864 | |--SEMI -> ; [1858:52]
21865 | `--RCURLY -> } [1859:4]
21866 |--METHOD_DEF -> METHOD_DEF [1861:4]
21867 | |--MODIFIERS -> MODIFIERS [1861:4]
21868 | | |--ANNOTATION -> ANNOTATION [1861:4]
21869 | | | |--AT -> @ [1861:4]
21870 | | | `--IDENT -> Test [1861:5]
21871 | | `--LITERAL_PUBLIC -> public [1862:4]
21872 | |--TYPE -> TYPE [1862:11]
21873 | | `--LITERAL_VOID -> void [1862:11]
21874 | |--IDENT -> testValidInterfaceDefWithChecker [1862:16]
21875 | |--LPAREN -> ( [1862:48]
21876 | |--PARAMETERS -> PARAMETERS [1862:49]
21877 | |--RPAREN -> ) [1862:49]
21878 | |--LITERAL_THROWS -> throws [1863:12]
21879 | | `--IDENT -> Exception [1863:19]
21880 | `--SLIST -> { [1863:29]
21881 | |--VARIABLE_DEF -> VARIABLE_DEF [1864:8]
21882 | | |--MODIFIERS -> MODIFIERS [1864:8]
21883 | | | `--FINAL -> final [1864:8]
21884 | | |--TYPE -> TYPE [1864:14]
21885 | | | `--IDENT -> DefaultConfiguration [1864:14]
21886 | | |--IDENT -> checkConfig [1864:35]
21887 | | `--ASSIGN -> = [1864:47]
21888 | | `--EXPR -> EXPR [1864:67]
21889 | | `--METHOD_CALL -> ( [1864:67]
21890 | | |--IDENT -> createModuleConfig [1864:49]
21891 | | |--ELIST -> ELIST [1864:84]
21892 | | | `--EXPR -> EXPR [1864:84]
21893 | | | `--DOT -> . [1864:84]
21894 | | | |--IDENT -> IndentationCheck [1864:68]
21895 | | | `--LITERAL_CLASS -> class [1864:85]
21896 | | `--RPAREN -> ) [1864:90]
21897 | |--SEMI -> ; [1864:91]
21898 | |--EXPR -> EXPR [1866:32]
21899 | | `--METHOD_CALL -> ( [1866:32]
21900 | | |--DOT -> . [1866:19]
21901 | | | |--IDENT -> checkConfig [1866:8]
21902 | | | `--IDENT -> addAttribute [1866:20]
21903 | | |--ELIST -> ELIST [1866:33]
21904 | | | |--EXPR -> EXPR [1866:33]
21905 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1866:33]
21906 | | | |--COMMA -> , [1866:50]
21907 | | | `--EXPR -> EXPR [1866:52]
21908 | | | `--STRING_LITERAL -> "4" [1866:52]
21909 | | `--RPAREN -> ) [1866:55]
21910 | |--SEMI -> ; [1866:56]
21911 | |--EXPR -> EXPR [1867:32]
21912 | | `--METHOD_CALL -> ( [1867:32]
21913 | | |--DOT -> . [1867:19]
21914 | | | |--IDENT -> checkConfig [1867:8]
21915 | | | `--IDENT -> addAttribute [1867:20]
21916 | | |--ELIST -> ELIST [1867:33]
21917 | | | |--EXPR -> EXPR [1867:33]
21918 | | | | `--STRING_LITERAL -> "basicOffset" [1867:33]
21919 | | | |--COMMA -> , [1867:46]
21920 | | | `--EXPR -> EXPR [1867:48]
21921 | | | `--STRING_LITERAL -> "4" [1867:48]
21922 | | `--RPAREN -> ) [1867:51]
21923 | |--SEMI -> ; [1867:52]
21924 | |--EXPR -> EXPR [1868:32]
21925 | | `--METHOD_CALL -> ( [1868:32]
21926 | | |--DOT -> . [1868:19]
21927 | | | |--IDENT -> checkConfig [1868:8]
21928 | | | `--IDENT -> addAttribute [1868:20]
21929 | | |--ELIST -> ELIST [1868:33]
21930 | | | |--EXPR -> EXPR [1868:33]
21931 | | | | `--STRING_LITERAL -> "braceAdjustment" [1868:33]
21932 | | | |--COMMA -> , [1868:50]
21933 | | | `--EXPR -> EXPR [1868:52]
21934 | | | `--STRING_LITERAL -> "0" [1868:52]
21935 | | `--RPAREN -> ) [1868:55]
21936 | |--SEMI -> ; [1868:56]
21937 | |--EXPR -> EXPR [1869:32]
21938 | | `--METHOD_CALL -> ( [1869:32]
21939 | | |--DOT -> . [1869:19]
21940 | | | |--IDENT -> checkConfig [1869:8]
21941 | | | `--IDENT -> addAttribute [1869:20]
21942 | | |--ELIST -> ELIST [1869:33]
21943 | | | |--EXPR -> EXPR [1869:33]
21944 | | | | `--STRING_LITERAL -> "caseIndent" [1869:33]
21945 | | | |--COMMA -> , [1869:45]
21946 | | | `--EXPR -> EXPR [1869:47]
21947 | | | `--STRING_LITERAL -> "4" [1869:47]
21948 | | `--RPAREN -> ) [1869:50]
21949 | |--SEMI -> ; [1869:51]
21950 | |--EXPR -> EXPR [1870:32]
21951 | | `--METHOD_CALL -> ( [1870:32]
21952 | | |--DOT -> . [1870:19]
21953 | | | |--IDENT -> checkConfig [1870:8]
21954 | | | `--IDENT -> addAttribute [1870:20]
21955 | | |--ELIST -> ELIST [1870:33]
21956 | | | |--EXPR -> EXPR [1870:33]
21957 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1870:33]
21958 | | | |--COMMA -> , [1870:55]
21959 | | | `--EXPR -> EXPR [1870:57]
21960 | | | `--STRING_LITERAL -> "false" [1870:57]
21961 | | `--RPAREN -> ) [1870:64]
21962 | |--SEMI -> ; [1870:65]
21963 | |--EXPR -> EXPR [1871:32]
21964 | | `--METHOD_CALL -> ( [1871:32]
21965 | | |--DOT -> . [1871:19]
21966 | | | |--IDENT -> checkConfig [1871:8]
21967 | | | `--IDENT -> addAttribute [1871:20]
21968 | | |--ELIST -> ELIST [1871:33]
21969 | | | |--EXPR -> EXPR [1871:33]
21970 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1871:33]
21971 | | | |--COMMA -> , [1871:58]
21972 | | | `--EXPR -> EXPR [1871:60]
21973 | | | `--STRING_LITERAL -> "4" [1871:60]
21974 | | `--RPAREN -> ) [1871:63]
21975 | |--SEMI -> ; [1871:64]
21976 | |--EXPR -> EXPR [1872:32]
21977 | | `--METHOD_CALL -> ( [1872:32]
21978 | | |--DOT -> . [1872:19]
21979 | | | |--IDENT -> checkConfig [1872:8]
21980 | | | `--IDENT -> addAttribute [1872:20]
21981 | | |--ELIST -> ELIST [1872:33]
21982 | | | |--EXPR -> EXPR [1872:33]
21983 | | | | `--STRING_LITERAL -> "tabWidth" [1872:33]
21984 | | | |--COMMA -> , [1872:43]
21985 | | | `--EXPR -> EXPR [1872:45]
21986 | | | `--STRING_LITERAL -> "4" [1872:45]
21987 | | `--RPAREN -> ) [1872:48]
21988 | |--SEMI -> ; [1872:49]
21989 | |--EXPR -> EXPR [1873:32]
21990 | | `--METHOD_CALL -> ( [1873:32]
21991 | | |--DOT -> . [1873:19]
21992 | | | |--IDENT -> checkConfig [1873:8]
21993 | | | `--IDENT -> addAttribute [1873:20]
21994 | | |--ELIST -> ELIST [1873:33]
21995 | | | |--EXPR -> EXPR [1873:33]
21996 | | | | `--STRING_LITERAL -> "throwsIndent" [1873:33]
21997 | | | |--COMMA -> , [1873:47]
21998 | | | `--EXPR -> EXPR [1873:49]
21999 | | | `--STRING_LITERAL -> "4" [1873:49]
22000 | | `--RPAREN -> ) [1873:52]
22001 | |--SEMI -> ; [1873:53]
22002 | |--VARIABLE_DEF -> VARIABLE_DEF [1874:8]
22003 | | |--MODIFIERS -> MODIFIERS [1874:8]
22004 | | | `--FINAL -> final [1874:8]
22005 | | |--TYPE -> TYPE [1874:14]
22006 | | | `--IDENT -> String [1874:14]
22007 | | |--IDENT -> fileName [1874:21]
22008 | | `--ASSIGN -> = [1874:30]
22009 | | `--EXPR -> EXPR [1874:39]
22010 | | `--METHOD_CALL -> ( [1874:39]
22011 | | |--IDENT -> getPath [1874:32]
22012 | | |--ELIST -> ELIST [1874:40]
22013 | | | `--EXPR -> EXPR [1874:40]
22014 | | | `--STRING_LITERAL -> "InputIndentationValidInterfaceDefIndent.java" [1874:40]
22015 | | `--RPAREN -> ) [1874:86]
22016 | |--SEMI -> ; [1874:87]
22017 | |--VARIABLE_DEF -> VARIABLE_DEF [1875:8]
22018 | | |--MODIFIERS -> MODIFIERS [1875:8]
22019 | | | `--FINAL -> final [1875:8]
22020 | | |--TYPE -> TYPE [1875:20]
22021 | | | `--ARRAY_DECLARATOR -> [ [1875:20]
22022 | | | |--IDENT -> String [1875:14]
22023 | | | `--RBRACK -> ] [1875:21]
22024 | | |--IDENT -> expected [1875:23]
22025 | | `--ASSIGN -> = [1875:32]
22026 | | `--EXPR -> EXPR [1875:44]
22027 | | `--DOT -> . [1875:44]
22028 | | |--IDENT -> CommonUtil [1875:34]
22029 | | `--IDENT -> EMPTY_STRING_ARRAY [1875:45]
22030 | |--SEMI -> ; [1875:63]
22031 | |--EXPR -> EXPR [1876:19]
22032 | | `--METHOD_CALL -> ( [1876:19]
22033 | | |--IDENT -> verifyWarns [1876:8]
22034 | | |--ELIST -> ELIST [1876:20]
22035 | | | |--EXPR -> EXPR [1876:20]
22036 | | | | `--IDENT -> checkConfig [1876:20]
22037 | | | |--COMMA -> , [1876:31]
22038 | | | |--EXPR -> EXPR [1876:33]
22039 | | | | `--IDENT -> fileName [1876:33]
22040 | | | |--COMMA -> , [1876:41]
22041 | | | `--EXPR -> EXPR [1876:43]
22042 | | | `--IDENT -> expected [1876:43]
22043 | | `--RPAREN -> ) [1876:51]
22044 | |--SEMI -> ; [1876:52]
22045 | `--RCURLY -> } [1877:4]
22046 |--METHOD_DEF -> METHOD_DEF [1879:4]
22047 | |--MODIFIERS -> MODIFIERS [1879:4]
22048 | | |--ANNOTATION -> ANNOTATION [1879:4]
22049 | | | |--AT -> @ [1879:4]
22050 | | | `--IDENT -> Test [1879:5]
22051 | | `--LITERAL_PUBLIC -> public [1880:4]
22052 | |--TYPE -> TYPE [1880:11]
22053 | | `--LITERAL_VOID -> void [1880:11]
22054 | |--IDENT -> testValidCommaWithChecker [1880:16]
22055 | |--LPAREN -> ( [1880:41]
22056 | |--PARAMETERS -> PARAMETERS [1880:42]
22057 | |--RPAREN -> ) [1880:42]
22058 | |--LITERAL_THROWS -> throws [1881:12]
22059 | | `--IDENT -> Exception [1881:19]
22060 | `--SLIST -> { [1881:29]
22061 | |--VARIABLE_DEF -> VARIABLE_DEF [1882:8]
22062 | | |--MODIFIERS -> MODIFIERS [1882:8]
22063 | | | `--FINAL -> final [1882:8]
22064 | | |--TYPE -> TYPE [1882:14]
22065 | | | `--IDENT -> DefaultConfiguration [1882:14]
22066 | | |--IDENT -> checkConfig [1882:35]
22067 | | `--ASSIGN -> = [1882:47]
22068 | | `--EXPR -> EXPR [1882:67]
22069 | | `--METHOD_CALL -> ( [1882:67]
22070 | | |--IDENT -> createModuleConfig [1882:49]
22071 | | |--ELIST -> ELIST [1882:84]
22072 | | | `--EXPR -> EXPR [1882:84]
22073 | | | `--DOT -> . [1882:84]
22074 | | | |--IDENT -> IndentationCheck [1882:68]
22075 | | | `--LITERAL_CLASS -> class [1882:85]
22076 | | `--RPAREN -> ) [1882:90]
22077 | |--SEMI -> ; [1882:91]
22078 | |--EXPR -> EXPR [1884:32]
22079 | | `--METHOD_CALL -> ( [1884:32]
22080 | | |--DOT -> . [1884:19]
22081 | | | |--IDENT -> checkConfig [1884:8]
22082 | | | `--IDENT -> addAttribute [1884:20]
22083 | | |--ELIST -> ELIST [1884:33]
22084 | | | |--EXPR -> EXPR [1884:33]
22085 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1884:33]
22086 | | | |--COMMA -> , [1884:50]
22087 | | | `--EXPR -> EXPR [1884:52]
22088 | | | `--STRING_LITERAL -> "4" [1884:52]
22089 | | `--RPAREN -> ) [1884:55]
22090 | |--SEMI -> ; [1884:56]
22091 | |--EXPR -> EXPR [1885:32]
22092 | | `--METHOD_CALL -> ( [1885:32]
22093 | | |--DOT -> . [1885:19]
22094 | | | |--IDENT -> checkConfig [1885:8]
22095 | | | `--IDENT -> addAttribute [1885:20]
22096 | | |--ELIST -> ELIST [1885:33]
22097 | | | |--EXPR -> EXPR [1885:33]
22098 | | | | `--STRING_LITERAL -> "basicOffset" [1885:33]
22099 | | | |--COMMA -> , [1885:46]
22100 | | | `--EXPR -> EXPR [1885:48]
22101 | | | `--STRING_LITERAL -> "4" [1885:48]
22102 | | `--RPAREN -> ) [1885:51]
22103 | |--SEMI -> ; [1885:52]
22104 | |--EXPR -> EXPR [1886:32]
22105 | | `--METHOD_CALL -> ( [1886:32]
22106 | | |--DOT -> . [1886:19]
22107 | | | |--IDENT -> checkConfig [1886:8]
22108 | | | `--IDENT -> addAttribute [1886:20]
22109 | | |--ELIST -> ELIST [1886:33]
22110 | | | |--EXPR -> EXPR [1886:33]
22111 | | | | `--STRING_LITERAL -> "braceAdjustment" [1886:33]
22112 | | | |--COMMA -> , [1886:50]
22113 | | | `--EXPR -> EXPR [1886:52]
22114 | | | `--STRING_LITERAL -> "0" [1886:52]
22115 | | `--RPAREN -> ) [1886:55]
22116 | |--SEMI -> ; [1886:56]
22117 | |--EXPR -> EXPR [1887:32]
22118 | | `--METHOD_CALL -> ( [1887:32]
22119 | | |--DOT -> . [1887:19]
22120 | | | |--IDENT -> checkConfig [1887:8]
22121 | | | `--IDENT -> addAttribute [1887:20]
22122 | | |--ELIST -> ELIST [1887:33]
22123 | | | |--EXPR -> EXPR [1887:33]
22124 | | | | `--STRING_LITERAL -> "caseIndent" [1887:33]
22125 | | | |--COMMA -> , [1887:45]
22126 | | | `--EXPR -> EXPR [1887:47]
22127 | | | `--STRING_LITERAL -> "4" [1887:47]
22128 | | `--RPAREN -> ) [1887:50]
22129 | |--SEMI -> ; [1887:51]
22130 | |--EXPR -> EXPR [1888:32]
22131 | | `--METHOD_CALL -> ( [1888:32]
22132 | | |--DOT -> . [1888:19]
22133 | | | |--IDENT -> checkConfig [1888:8]
22134 | | | `--IDENT -> addAttribute [1888:20]
22135 | | |--ELIST -> ELIST [1888:33]
22136 | | | |--EXPR -> EXPR [1888:33]
22137 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1888:33]
22138 | | | |--COMMA -> , [1888:55]
22139 | | | `--EXPR -> EXPR [1888:57]
22140 | | | `--STRING_LITERAL -> "false" [1888:57]
22141 | | `--RPAREN -> ) [1888:64]
22142 | |--SEMI -> ; [1888:65]
22143 | |--EXPR -> EXPR [1889:32]
22144 | | `--METHOD_CALL -> ( [1889:32]
22145 | | |--DOT -> . [1889:19]
22146 | | | |--IDENT -> checkConfig [1889:8]
22147 | | | `--IDENT -> addAttribute [1889:20]
22148 | | |--ELIST -> ELIST [1889:33]
22149 | | | |--EXPR -> EXPR [1889:33]
22150 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1889:33]
22151 | | | |--COMMA -> , [1889:58]
22152 | | | `--EXPR -> EXPR [1889:60]
22153 | | | `--STRING_LITERAL -> "4" [1889:60]
22154 | | `--RPAREN -> ) [1889:63]
22155 | |--SEMI -> ; [1889:64]
22156 | |--EXPR -> EXPR [1890:32]
22157 | | `--METHOD_CALL -> ( [1890:32]
22158 | | |--DOT -> . [1890:19]
22159 | | | |--IDENT -> checkConfig [1890:8]
22160 | | | `--IDENT -> addAttribute [1890:20]
22161 | | |--ELIST -> ELIST [1890:33]
22162 | | | |--EXPR -> EXPR [1890:33]
22163 | | | | `--STRING_LITERAL -> "tabWidth" [1890:33]
22164 | | | |--COMMA -> , [1890:43]
22165 | | | `--EXPR -> EXPR [1890:45]
22166 | | | `--STRING_LITERAL -> "4" [1890:45]
22167 | | `--RPAREN -> ) [1890:48]
22168 | |--SEMI -> ; [1890:49]
22169 | |--EXPR -> EXPR [1891:32]
22170 | | `--METHOD_CALL -> ( [1891:32]
22171 | | |--DOT -> . [1891:19]
22172 | | | |--IDENT -> checkConfig [1891:8]
22173 | | | `--IDENT -> addAttribute [1891:20]
22174 | | |--ELIST -> ELIST [1891:33]
22175 | | | |--EXPR -> EXPR [1891:33]
22176 | | | | `--STRING_LITERAL -> "throwsIndent" [1891:33]
22177 | | | |--COMMA -> , [1891:47]
22178 | | | `--EXPR -> EXPR [1891:49]
22179 | | | `--STRING_LITERAL -> "4" [1891:49]
22180 | | `--RPAREN -> ) [1891:52]
22181 | |--SEMI -> ; [1891:53]
22182 | |--VARIABLE_DEF -> VARIABLE_DEF [1892:8]
22183 | | |--MODIFIERS -> MODIFIERS [1892:8]
22184 | | | `--FINAL -> final [1892:8]
22185 | | |--TYPE -> TYPE [1892:14]
22186 | | | `--IDENT -> String [1892:14]
22187 | | |--IDENT -> fileName [1892:21]
22188 | | `--ASSIGN -> = [1892:30]
22189 | | `--EXPR -> EXPR [1892:39]
22190 | | `--METHOD_CALL -> ( [1892:39]
22191 | | |--IDENT -> getPath [1892:32]
22192 | | |--ELIST -> ELIST [1892:40]
22193 | | | `--EXPR -> EXPR [1892:40]
22194 | | | `--STRING_LITERAL -> "InputIndentationValidCommaIndent.java" [1892:40]
22195 | | `--RPAREN -> ) [1892:79]
22196 | |--SEMI -> ; [1892:80]
22197 | |--VARIABLE_DEF -> VARIABLE_DEF [1893:8]
22198 | | |--MODIFIERS -> MODIFIERS [1893:8]
22199 | | | `--FINAL -> final [1893:8]
22200 | | |--TYPE -> TYPE [1893:20]
22201 | | | `--ARRAY_DECLARATOR -> [ [1893:20]
22202 | | | |--IDENT -> String [1893:14]
22203 | | | `--RBRACK -> ] [1893:21]
22204 | | |--IDENT -> expected [1893:23]
22205 | | `--ASSIGN -> = [1893:32]
22206 | | `--EXPR -> EXPR [1893:44]
22207 | | `--DOT -> . [1893:44]
22208 | | |--IDENT -> CommonUtil [1893:34]
22209 | | `--IDENT -> EMPTY_STRING_ARRAY [1893:45]
22210 | |--SEMI -> ; [1893:63]
22211 | |--EXPR -> EXPR [1894:19]
22212 | | `--METHOD_CALL -> ( [1894:19]
22213 | | |--IDENT -> verifyWarns [1894:8]
22214 | | |--ELIST -> ELIST [1894:20]
22215 | | | |--EXPR -> EXPR [1894:20]
22216 | | | | `--IDENT -> checkConfig [1894:20]
22217 | | | |--COMMA -> , [1894:31]
22218 | | | |--EXPR -> EXPR [1894:33]
22219 | | | | `--IDENT -> fileName [1894:33]
22220 | | | |--COMMA -> , [1894:41]
22221 | | | `--EXPR -> EXPR [1894:43]
22222 | | | `--IDENT -> expected [1894:43]
22223 | | `--RPAREN -> ) [1894:51]
22224 | |--SEMI -> ; [1894:52]
22225 | `--RCURLY -> } [1895:4]
22226 |--METHOD_DEF -> METHOD_DEF [1897:4]
22227 | |--MODIFIERS -> MODIFIERS [1897:4]
22228 | | |--ANNOTATION -> ANNOTATION [1897:4]
22229 | | | |--AT -> @ [1897:4]
22230 | | | `--IDENT -> Test [1897:5]
22231 | | `--LITERAL_PUBLIC -> public [1898:4]
22232 | |--TYPE -> TYPE [1898:11]
22233 | | `--LITERAL_VOID -> void [1898:11]
22234 | |--IDENT -> testTabs [1898:16]
22235 | |--LPAREN -> ( [1898:24]
22236 | |--PARAMETERS -> PARAMETERS [1898:25]
22237 | |--RPAREN -> ) [1898:25]
22238 | |--LITERAL_THROWS -> throws [1898:27]
22239 | | `--IDENT -> Exception [1898:34]
22240 | `--SLIST -> { [1898:44]
22241 | |--VARIABLE_DEF -> VARIABLE_DEF [1899:8]
22242 | | |--MODIFIERS -> MODIFIERS [1899:8]
22243 | | | `--FINAL -> final [1899:8]
22244 | | |--TYPE -> TYPE [1899:14]
22245 | | | `--IDENT -> DefaultConfiguration [1899:14]
22246 | | |--IDENT -> checkConfig [1899:35]
22247 | | `--ASSIGN -> = [1899:47]
22248 | | `--EXPR -> EXPR [1899:67]
22249 | | `--METHOD_CALL -> ( [1899:67]
22250 | | |--IDENT -> createModuleConfig [1899:49]
22251 | | |--ELIST -> ELIST [1899:84]
22252 | | | `--EXPR -> EXPR [1899:84]
22253 | | | `--DOT -> . [1899:84]
22254 | | | |--IDENT -> IndentationCheck [1899:68]
22255 | | | `--LITERAL_CLASS -> class [1899:85]
22256 | | `--RPAREN -> ) [1899:90]
22257 | |--SEMI -> ; [1899:91]
22258 | |--EXPR -> EXPR [1901:32]
22259 | | `--METHOD_CALL -> ( [1901:32]
22260 | | |--DOT -> . [1901:19]
22261 | | | |--IDENT -> checkConfig [1901:8]
22262 | | | `--IDENT -> addAttribute [1901:20]
22263 | | |--ELIST -> ELIST [1901:33]
22264 | | | |--EXPR -> EXPR [1901:33]
22265 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1901:33]
22266 | | | |--COMMA -> , [1901:50]
22267 | | | `--EXPR -> EXPR [1901:52]
22268 | | | `--STRING_LITERAL -> "4" [1901:52]
22269 | | `--RPAREN -> ) [1901:55]
22270 | |--SEMI -> ; [1901:56]
22271 | |--EXPR -> EXPR [1902:32]
22272 | | `--METHOD_CALL -> ( [1902:32]
22273 | | |--DOT -> . [1902:19]
22274 | | | |--IDENT -> checkConfig [1902:8]
22275 | | | `--IDENT -> addAttribute [1902:20]
22276 | | |--ELIST -> ELIST [1902:33]
22277 | | | |--EXPR -> EXPR [1902:33]
22278 | | | | `--STRING_LITERAL -> "basicOffset" [1902:33]
22279 | | | |--COMMA -> , [1902:46]
22280 | | | `--EXPR -> EXPR [1902:48]
22281 | | | `--STRING_LITERAL -> "4" [1902:48]
22282 | | `--RPAREN -> ) [1902:51]
22283 | |--SEMI -> ; [1902:52]
22284 | |--EXPR -> EXPR [1903:32]
22285 | | `--METHOD_CALL -> ( [1903:32]
22286 | | |--DOT -> . [1903:19]
22287 | | | |--IDENT -> checkConfig [1903:8]
22288 | | | `--IDENT -> addAttribute [1903:20]
22289 | | |--ELIST -> ELIST [1903:33]
22290 | | | |--EXPR -> EXPR [1903:33]
22291 | | | | `--STRING_LITERAL -> "braceAdjustment" [1903:33]
22292 | | | |--COMMA -> , [1903:50]
22293 | | | `--EXPR -> EXPR [1903:52]
22294 | | | `--STRING_LITERAL -> "0" [1903:52]
22295 | | `--RPAREN -> ) [1903:55]
22296 | |--SEMI -> ; [1903:56]
22297 | |--EXPR -> EXPR [1904:32]
22298 | | `--METHOD_CALL -> ( [1904:32]
22299 | | |--DOT -> . [1904:19]
22300 | | | |--IDENT -> checkConfig [1904:8]
22301 | | | `--IDENT -> addAttribute [1904:20]
22302 | | |--ELIST -> ELIST [1904:33]
22303 | | | |--EXPR -> EXPR [1904:33]
22304 | | | | `--STRING_LITERAL -> "caseIndent" [1904:33]
22305 | | | |--COMMA -> , [1904:45]
22306 | | | `--EXPR -> EXPR [1904:47]
22307 | | | `--STRING_LITERAL -> "4" [1904:47]
22308 | | `--RPAREN -> ) [1904:50]
22309 | |--SEMI -> ; [1904:51]
22310 | |--EXPR -> EXPR [1905:32]
22311 | | `--METHOD_CALL -> ( [1905:32]
22312 | | |--DOT -> . [1905:19]
22313 | | | |--IDENT -> checkConfig [1905:8]
22314 | | | `--IDENT -> addAttribute [1905:20]
22315 | | |--ELIST -> ELIST [1905:33]
22316 | | | |--EXPR -> EXPR [1905:33]
22317 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1905:33]
22318 | | | |--COMMA -> , [1905:55]
22319 | | | `--EXPR -> EXPR [1905:57]
22320 | | | `--STRING_LITERAL -> "false" [1905:57]
22321 | | `--RPAREN -> ) [1905:64]
22322 | |--SEMI -> ; [1905:65]
22323 | |--EXPR -> EXPR [1906:32]
22324 | | `--METHOD_CALL -> ( [1906:32]
22325 | | |--DOT -> . [1906:19]
22326 | | | |--IDENT -> checkConfig [1906:8]
22327 | | | `--IDENT -> addAttribute [1906:20]
22328 | | |--ELIST -> ELIST [1906:33]
22329 | | | |--EXPR -> EXPR [1906:33]
22330 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1906:33]
22331 | | | |--COMMA -> , [1906:58]
22332 | | | `--EXPR -> EXPR [1906:60]
22333 | | | `--STRING_LITERAL -> "4" [1906:60]
22334 | | `--RPAREN -> ) [1906:63]
22335 | |--SEMI -> ; [1906:64]
22336 | |--EXPR -> EXPR [1907:32]
22337 | | `--METHOD_CALL -> ( [1907:32]
22338 | | |--DOT -> . [1907:19]
22339 | | | |--IDENT -> checkConfig [1907:8]
22340 | | | `--IDENT -> addAttribute [1907:20]
22341 | | |--ELIST -> ELIST [1907:33]
22342 | | | |--EXPR -> EXPR [1907:33]
22343 | | | | `--STRING_LITERAL -> "tabWidth" [1907:33]
22344 | | | |--COMMA -> , [1907:43]
22345 | | | `--EXPR -> EXPR [1907:45]
22346 | | | `--STRING_LITERAL -> "4" [1907:45]
22347 | | `--RPAREN -> ) [1907:48]
22348 | |--SEMI -> ; [1907:49]
22349 | |--EXPR -> EXPR [1908:32]
22350 | | `--METHOD_CALL -> ( [1908:32]
22351 | | |--DOT -> . [1908:19]
22352 | | | |--IDENT -> checkConfig [1908:8]
22353 | | | `--IDENT -> addAttribute [1908:20]
22354 | | |--ELIST -> ELIST [1908:33]
22355 | | | |--EXPR -> EXPR [1908:33]
22356 | | | | `--STRING_LITERAL -> "throwsIndent" [1908:33]
22357 | | | |--COMMA -> , [1908:47]
22358 | | | `--EXPR -> EXPR [1908:49]
22359 | | | `--STRING_LITERAL -> "4" [1908:49]
22360 | | `--RPAREN -> ) [1908:52]
22361 | |--SEMI -> ; [1908:53]
22362 | |--VARIABLE_DEF -> VARIABLE_DEF [1909:8]
22363 | | |--MODIFIERS -> MODIFIERS [1909:8]
22364 | | | `--FINAL -> final [1909:8]
22365 | | |--TYPE -> TYPE [1909:20]
22366 | | | `--ARRAY_DECLARATOR -> [ [1909:20]
22367 | | | |--IDENT -> String [1909:14]
22368 | | | `--RBRACK -> ] [1909:21]
22369 | | |--IDENT -> expected [1909:23]
22370 | | `--ASSIGN -> = [1909:32]
22371 | | `--ARRAY_INIT -> { [1909:34]
22372 | | |--EXPR -> EXPR [1910:22]
22373 | | | `--PLUS -> + [1910:22]
22374 | | | |--STRING_LITERAL -> "29:10: " [1910:12]
22375 | | | `--METHOD_CALL -> ( [1910:39]
22376 | | | |--IDENT -> getCheckMessage [1910:24]
22377 | | | |--ELIST -> ELIST [1910:40]
22378 | | | | |--EXPR -> EXPR [1910:40]
22379 | | | | | `--IDENT -> MSG_CHILD_ERROR [1910:40]
22380 | | | | |--COMMA -> , [1910:55]
22381 | | | | |--EXPR -> EXPR [1910:57]
22382 | | | | | `--STRING_LITERAL -> "ctor def" [1910:57]
22383 | | | | |--COMMA -> , [1910:67]
22384 | | | | |--EXPR -> EXPR [1910:69]
22385 | | | | | `--NUM_INT -> 9 [1910:69]
22386 | | | | |--COMMA -> , [1910:70]
22387 | | | | `--EXPR -> EXPR [1910:72]
22388 | | | | `--NUM_INT -> 8 [1910:72]
22389 | | | `--RPAREN -> ) [1910:73]
22390 | | |--COMMA -> , [1910:74]
22391 | | `--RCURLY -> } [1911:8]
22392 | |--SEMI -> ; [1911:9]
22393 | |--EXPR -> EXPR [1912:19]
22394 | | `--METHOD_CALL -> ( [1912:19]
22395 | | |--IDENT -> verifyWarns [1912:8]
22396 | | |--ELIST -> ELIST [1912:20]
22397 | | | |--EXPR -> EXPR [1912:20]
22398 | | | | `--IDENT -> checkConfig [1912:20]
22399 | | | |--COMMA -> , [1912:31]
22400 | | | |--EXPR -> EXPR [1912:40]
22401 | | | | `--METHOD_CALL -> ( [1912:40]
22402 | | | | |--IDENT -> getPath [1912:33]
22403 | | | | |--ELIST -> ELIST [1912:41]
22404 | | | | | `--EXPR -> EXPR [1912:41]
22405 | | | | | `--STRING_LITERAL -> "InputIndentationUseTabs.java" [1912:41]
22406 | | | | `--RPAREN -> ) [1912:71]
22407 | | | |--COMMA -> , [1912:72]
22408 | | | `--EXPR -> EXPR [1912:74]
22409 | | | `--IDENT -> expected [1912:74]
22410 | | `--RPAREN -> ) [1912:82]
22411 | |--SEMI -> ; [1912:83]
22412 | `--RCURLY -> } [1913:4]
22413 |--METHOD_DEF -> METHOD_DEF [1915:4]
22414 | |--MODIFIERS -> MODIFIERS [1915:4]
22415 | | |--ANNOTATION -> ANNOTATION [1915:4]
22416 | | | |--AT -> @ [1915:4]
22417 | | | `--IDENT -> Test [1915:5]
22418 | | `--LITERAL_PUBLIC -> public [1916:4]
22419 | |--TYPE -> TYPE [1916:11]
22420 | | `--LITERAL_VOID -> void [1916:11]
22421 | |--IDENT -> testIndentationLevel [1916:16]
22422 | |--LPAREN -> ( [1916:36]
22423 | |--PARAMETERS -> PARAMETERS [1916:37]
22424 | |--RPAREN -> ) [1916:37]
22425 | |--LITERAL_THROWS -> throws [1916:39]
22426 | | `--IDENT -> Exception [1916:46]
22427 | `--SLIST -> { [1916:56]
22428 | |--VARIABLE_DEF -> VARIABLE_DEF [1917:8]
22429 | | |--MODIFIERS -> MODIFIERS [1917:8]
22430 | | | `--FINAL -> final [1917:8]
22431 | | |--TYPE -> TYPE [1917:14]
22432 | | | `--IDENT -> DefaultConfiguration [1917:14]
22433 | | |--IDENT -> checkConfig [1917:35]
22434 | | `--ASSIGN -> = [1917:47]
22435 | | `--EXPR -> EXPR [1917:67]
22436 | | `--METHOD_CALL -> ( [1917:67]
22437 | | |--IDENT -> createModuleConfig [1917:49]
22438 | | |--ELIST -> ELIST [1917:84]
22439 | | | `--EXPR -> EXPR [1917:84]
22440 | | | `--DOT -> . [1917:84]
22441 | | | |--IDENT -> IndentationCheck [1917:68]
22442 | | | `--LITERAL_CLASS -> class [1917:85]
22443 | | `--RPAREN -> ) [1917:90]
22444 | |--SEMI -> ; [1917:91]
22445 | |--EXPR -> EXPR [1919:32]
22446 | | `--METHOD_CALL -> ( [1919:32]
22447 | | |--DOT -> . [1919:19]
22448 | | | |--IDENT -> checkConfig [1919:8]
22449 | | | `--IDENT -> addAttribute [1919:20]
22450 | | |--ELIST -> ELIST [1919:33]
22451 | | | |--EXPR -> EXPR [1919:33]
22452 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1919:33]
22453 | | | |--COMMA -> , [1919:50]
22454 | | | `--EXPR -> EXPR [1919:52]
22455 | | | `--STRING_LITERAL -> "4" [1919:52]
22456 | | `--RPAREN -> ) [1919:55]
22457 | |--SEMI -> ; [1919:56]
22458 | |--EXPR -> EXPR [1920:32]
22459 | | `--METHOD_CALL -> ( [1920:32]
22460 | | |--DOT -> . [1920:19]
22461 | | | |--IDENT -> checkConfig [1920:8]
22462 | | | `--IDENT -> addAttribute [1920:20]
22463 | | |--ELIST -> ELIST [1920:33]
22464 | | | |--EXPR -> EXPR [1920:33]
22465 | | | | `--STRING_LITERAL -> "basicOffset" [1920:33]
22466 | | | |--COMMA -> , [1920:46]
22467 | | | `--EXPR -> EXPR [1920:48]
22468 | | | `--STRING_LITERAL -> "2" [1920:48]
22469 | | `--RPAREN -> ) [1920:51]
22470 | |--SEMI -> ; [1920:52]
22471 | |--EXPR -> EXPR [1921:32]
22472 | | `--METHOD_CALL -> ( [1921:32]
22473 | | |--DOT -> . [1921:19]
22474 | | | |--IDENT -> checkConfig [1921:8]
22475 | | | `--IDENT -> addAttribute [1921:20]
22476 | | |--ELIST -> ELIST [1921:33]
22477 | | | |--EXPR -> EXPR [1921:33]
22478 | | | | `--STRING_LITERAL -> "braceAdjustment" [1921:33]
22479 | | | |--COMMA -> , [1921:50]
22480 | | | `--EXPR -> EXPR [1921:52]
22481 | | | `--STRING_LITERAL -> "0" [1921:52]
22482 | | `--RPAREN -> ) [1921:55]
22483 | |--SEMI -> ; [1921:56]
22484 | |--EXPR -> EXPR [1922:32]
22485 | | `--METHOD_CALL -> ( [1922:32]
22486 | | |--DOT -> . [1922:19]
22487 | | | |--IDENT -> checkConfig [1922:8]
22488 | | | `--IDENT -> addAttribute [1922:20]
22489 | | |--ELIST -> ELIST [1922:33]
22490 | | | |--EXPR -> EXPR [1922:33]
22491 | | | | `--STRING_LITERAL -> "caseIndent" [1922:33]
22492 | | | |--COMMA -> , [1922:45]
22493 | | | `--EXPR -> EXPR [1922:47]
22494 | | | `--STRING_LITERAL -> "4" [1922:47]
22495 | | `--RPAREN -> ) [1922:50]
22496 | |--SEMI -> ; [1922:51]
22497 | |--EXPR -> EXPR [1923:32]
22498 | | `--METHOD_CALL -> ( [1923:32]
22499 | | |--DOT -> . [1923:19]
22500 | | | |--IDENT -> checkConfig [1923:8]
22501 | | | `--IDENT -> addAttribute [1923:20]
22502 | | |--ELIST -> ELIST [1923:33]
22503 | | | |--EXPR -> EXPR [1923:33]
22504 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1923:33]
22505 | | | |--COMMA -> , [1923:55]
22506 | | | `--EXPR -> EXPR [1923:57]
22507 | | | `--STRING_LITERAL -> "false" [1923:57]
22508 | | `--RPAREN -> ) [1923:64]
22509 | |--SEMI -> ; [1923:65]
22510 | |--EXPR -> EXPR [1924:32]
22511 | | `--METHOD_CALL -> ( [1924:32]
22512 | | |--DOT -> . [1924:19]
22513 | | | |--IDENT -> checkConfig [1924:8]
22514 | | | `--IDENT -> addAttribute [1924:20]
22515 | | |--ELIST -> ELIST [1924:33]
22516 | | | |--EXPR -> EXPR [1924:33]
22517 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1924:33]
22518 | | | |--COMMA -> , [1924:58]
22519 | | | `--EXPR -> EXPR [1924:60]
22520 | | | `--STRING_LITERAL -> "2" [1924:60]
22521 | | `--RPAREN -> ) [1924:63]
22522 | |--SEMI -> ; [1924:64]
22523 | |--EXPR -> EXPR [1925:32]
22524 | | `--METHOD_CALL -> ( [1925:32]
22525 | | |--DOT -> . [1925:19]
22526 | | | |--IDENT -> checkConfig [1925:8]
22527 | | | `--IDENT -> addAttribute [1925:20]
22528 | | |--ELIST -> ELIST [1925:33]
22529 | | | |--EXPR -> EXPR [1925:33]
22530 | | | | `--STRING_LITERAL -> "tabWidth" [1925:33]
22531 | | | |--COMMA -> , [1925:43]
22532 | | | `--EXPR -> EXPR [1925:45]
22533 | | | `--STRING_LITERAL -> "4" [1925:45]
22534 | | `--RPAREN -> ) [1925:48]
22535 | |--SEMI -> ; [1925:49]
22536 | |--EXPR -> EXPR [1926:32]
22537 | | `--METHOD_CALL -> ( [1926:32]
22538 | | |--DOT -> . [1926:19]
22539 | | | |--IDENT -> checkConfig [1926:8]
22540 | | | `--IDENT -> addAttribute [1926:20]
22541 | | |--ELIST -> ELIST [1926:33]
22542 | | | |--EXPR -> EXPR [1926:33]
22543 | | | | `--STRING_LITERAL -> "throwsIndent" [1926:33]
22544 | | | |--COMMA -> , [1926:47]
22545 | | | `--EXPR -> EXPR [1926:49]
22546 | | | `--STRING_LITERAL -> "4" [1926:49]
22547 | | `--RPAREN -> ) [1926:52]
22548 | |--SEMI -> ; [1926:53]
22549 | |--VARIABLE_DEF -> VARIABLE_DEF [1927:8]
22550 | | |--MODIFIERS -> MODIFIERS [1927:8]
22551 | | | `--FINAL -> final [1927:8]
22552 | | |--TYPE -> TYPE [1927:20]
22553 | | | `--ARRAY_DECLARATOR -> [ [1927:20]
22554 | | | |--IDENT -> String [1927:14]
22555 | | | `--RBRACK -> ] [1927:21]
22556 | | |--IDENT -> expected [1927:23]
22557 | | `--ASSIGN -> = [1927:32]
22558 | | `--ARRAY_INIT -> { [1927:34]
22559 | | |--EXPR -> EXPR [1928:21]
22560 | | | `--PLUS -> + [1928:21]
22561 | | | |--STRING_LITERAL -> "29:6: " [1928:12]
22562 | | | `--METHOD_CALL -> ( [1928:38]
22563 | | | |--IDENT -> getCheckMessage [1928:23]
22564 | | | |--ELIST -> ELIST [1928:39]
22565 | | | | |--EXPR -> EXPR [1928:39]
22566 | | | | | `--IDENT -> MSG_CHILD_ERROR [1928:39]
22567 | | | | |--COMMA -> , [1928:54]
22568 | | | | |--EXPR -> EXPR [1928:56]
22569 | | | | | `--STRING_LITERAL -> "ctor def" [1928:56]
22570 | | | | |--COMMA -> , [1928:66]
22571 | | | | |--EXPR -> EXPR [1928:68]
22572 | | | | | `--NUM_INT -> 5 [1928:68]
22573 | | | | |--COMMA -> , [1928:69]
22574 | | | | `--EXPR -> EXPR [1928:71]
22575 | | | | `--NUM_INT -> 4 [1928:71]
22576 | | | `--RPAREN -> ) [1928:72]
22577 | | |--COMMA -> , [1928:73]
22578 | | `--RCURLY -> } [1929:8]
22579 | |--SEMI -> ; [1929:9]
22580 | |--EXPR -> EXPR [1930:19]
22581 | | `--METHOD_CALL -> ( [1930:19]
22582 | | |--IDENT -> verifyWarns [1930:8]
22583 | | |--ELIST -> ELIST [1930:20]
22584 | | | |--EXPR -> EXPR [1930:20]
22585 | | | | `--IDENT -> checkConfig [1930:20]
22586 | | | |--COMMA -> , [1930:31]
22587 | | | |--EXPR -> EXPR [1930:40]
22588 | | | | `--METHOD_CALL -> ( [1930:40]
22589 | | | | |--IDENT -> getPath [1930:33]
22590 | | | | |--ELIST -> ELIST [1930:41]
22591 | | | | | `--EXPR -> EXPR [1930:41]
22592 | | | | | `--STRING_LITERAL -> "InputIndentationUseTwoSpaces.java" [1930:41]
22593 | | | | `--RPAREN -> ) [1930:76]
22594 | | | |--COMMA -> , [1930:77]
22595 | | | `--EXPR -> EXPR [1930:79]
22596 | | | `--IDENT -> expected [1930:79]
22597 | | `--RPAREN -> ) [1930:87]
22598 | |--SEMI -> ; [1930:88]
22599 | `--RCURLY -> } [1931:4]
22600 |--METHOD_DEF -> METHOD_DEF [1933:4]
22601 | |--MODIFIERS -> MODIFIERS [1933:4]
22602 | | |--ANNOTATION -> ANNOTATION [1933:4]
22603 | | | |--AT -> @ [1933:4]
22604 | | | `--IDENT -> Test [1933:5]
22605 | | `--LITERAL_PUBLIC -> public [1934:4]
22606 | |--TYPE -> TYPE [1934:11]
22607 | | `--LITERAL_VOID -> void [1934:11]
22608 | |--IDENT -> testThrowsIndentationLevel [1934:16]
22609 | |--LPAREN -> ( [1934:42]
22610 | |--PARAMETERS -> PARAMETERS [1934:43]
22611 | |--RPAREN -> ) [1934:43]
22612 | |--LITERAL_THROWS -> throws [1934:45]
22613 | | `--IDENT -> Exception [1934:52]
22614 | `--SLIST -> { [1934:62]
22615 | |--VARIABLE_DEF -> VARIABLE_DEF [1935:8]
22616 | | |--MODIFIERS -> MODIFIERS [1935:8]
22617 | | | `--FINAL -> final [1935:8]
22618 | | |--TYPE -> TYPE [1935:14]
22619 | | | `--IDENT -> DefaultConfiguration [1935:14]
22620 | | |--IDENT -> checkConfig [1935:35]
22621 | | `--ASSIGN -> = [1935:47]
22622 | | `--EXPR -> EXPR [1935:67]
22623 | | `--METHOD_CALL -> ( [1935:67]
22624 | | |--IDENT -> createModuleConfig [1935:49]
22625 | | |--ELIST -> ELIST [1935:84]
22626 | | | `--EXPR -> EXPR [1935:84]
22627 | | | `--DOT -> . [1935:84]
22628 | | | |--IDENT -> IndentationCheck [1935:68]
22629 | | | `--LITERAL_CLASS -> class [1935:85]
22630 | | `--RPAREN -> ) [1935:90]
22631 | |--SEMI -> ; [1935:91]
22632 | |--EXPR -> EXPR [1937:32]
22633 | | `--METHOD_CALL -> ( [1937:32]
22634 | | |--DOT -> . [1937:19]
22635 | | | |--IDENT -> checkConfig [1937:8]
22636 | | | `--IDENT -> addAttribute [1937:20]
22637 | | |--ELIST -> ELIST [1937:33]
22638 | | | |--EXPR -> EXPR [1937:33]
22639 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1937:33]
22640 | | | |--COMMA -> , [1937:50]
22641 | | | `--EXPR -> EXPR [1937:52]
22642 | | | `--STRING_LITERAL -> "4" [1937:52]
22643 | | `--RPAREN -> ) [1937:55]
22644 | |--SEMI -> ; [1937:56]
22645 | |--EXPR -> EXPR [1938:32]
22646 | | `--METHOD_CALL -> ( [1938:32]
22647 | | |--DOT -> . [1938:19]
22648 | | | |--IDENT -> checkConfig [1938:8]
22649 | | | `--IDENT -> addAttribute [1938:20]
22650 | | |--ELIST -> ELIST [1938:33]
22651 | | | |--EXPR -> EXPR [1938:33]
22652 | | | | `--STRING_LITERAL -> "basicOffset" [1938:33]
22653 | | | |--COMMA -> , [1938:46]
22654 | | | `--EXPR -> EXPR [1938:48]
22655 | | | `--STRING_LITERAL -> "4" [1938:48]
22656 | | `--RPAREN -> ) [1938:51]
22657 | |--SEMI -> ; [1938:52]
22658 | |--EXPR -> EXPR [1939:32]
22659 | | `--METHOD_CALL -> ( [1939:32]
22660 | | |--DOT -> . [1939:19]
22661 | | | |--IDENT -> checkConfig [1939:8]
22662 | | | `--IDENT -> addAttribute [1939:20]
22663 | | |--ELIST -> ELIST [1939:33]
22664 | | | |--EXPR -> EXPR [1939:33]
22665 | | | | `--STRING_LITERAL -> "braceAdjustment" [1939:33]
22666 | | | |--COMMA -> , [1939:50]
22667 | | | `--EXPR -> EXPR [1939:52]
22668 | | | `--STRING_LITERAL -> "0" [1939:52]
22669 | | `--RPAREN -> ) [1939:55]
22670 | |--SEMI -> ; [1939:56]
22671 | |--EXPR -> EXPR [1940:32]
22672 | | `--METHOD_CALL -> ( [1940:32]
22673 | | |--DOT -> . [1940:19]
22674 | | | |--IDENT -> checkConfig [1940:8]
22675 | | | `--IDENT -> addAttribute [1940:20]
22676 | | |--ELIST -> ELIST [1940:33]
22677 | | | |--EXPR -> EXPR [1940:33]
22678 | | | | `--STRING_LITERAL -> "caseIndent" [1940:33]
22679 | | | |--COMMA -> , [1940:45]
22680 | | | `--EXPR -> EXPR [1940:47]
22681 | | | `--STRING_LITERAL -> "4" [1940:47]
22682 | | `--RPAREN -> ) [1940:50]
22683 | |--SEMI -> ; [1940:51]
22684 | |--EXPR -> EXPR [1941:32]
22685 | | `--METHOD_CALL -> ( [1941:32]
22686 | | |--DOT -> . [1941:19]
22687 | | | |--IDENT -> checkConfig [1941:8]
22688 | | | `--IDENT -> addAttribute [1941:20]
22689 | | |--ELIST -> ELIST [1941:33]
22690 | | | |--EXPR -> EXPR [1941:33]
22691 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1941:33]
22692 | | | |--COMMA -> , [1941:55]
22693 | | | `--EXPR -> EXPR [1941:57]
22694 | | | `--STRING_LITERAL -> "false" [1941:57]
22695 | | `--RPAREN -> ) [1941:64]
22696 | |--SEMI -> ; [1941:65]
22697 | |--EXPR -> EXPR [1942:32]
22698 | | `--METHOD_CALL -> ( [1942:32]
22699 | | |--DOT -> . [1942:19]
22700 | | | |--IDENT -> checkConfig [1942:8]
22701 | | | `--IDENT -> addAttribute [1942:20]
22702 | | |--ELIST -> ELIST [1942:33]
22703 | | | |--EXPR -> EXPR [1942:33]
22704 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1942:33]
22705 | | | |--COMMA -> , [1942:58]
22706 | | | `--EXPR -> EXPR [1942:60]
22707 | | | `--STRING_LITERAL -> "4" [1942:60]
22708 | | `--RPAREN -> ) [1942:63]
22709 | |--SEMI -> ; [1942:64]
22710 | |--EXPR -> EXPR [1943:32]
22711 | | `--METHOD_CALL -> ( [1943:32]
22712 | | |--DOT -> . [1943:19]
22713 | | | |--IDENT -> checkConfig [1943:8]
22714 | | | `--IDENT -> addAttribute [1943:20]
22715 | | |--ELIST -> ELIST [1943:33]
22716 | | | |--EXPR -> EXPR [1943:33]
22717 | | | | `--STRING_LITERAL -> "tabWidth" [1943:33]
22718 | | | |--COMMA -> , [1943:43]
22719 | | | `--EXPR -> EXPR [1943:45]
22720 | | | `--STRING_LITERAL -> "4" [1943:45]
22721 | | `--RPAREN -> ) [1943:48]
22722 | |--SEMI -> ; [1943:49]
22723 | |--EXPR -> EXPR [1944:32]
22724 | | `--METHOD_CALL -> ( [1944:32]
22725 | | |--DOT -> . [1944:19]
22726 | | | |--IDENT -> checkConfig [1944:8]
22727 | | | `--IDENT -> addAttribute [1944:20]
22728 | | |--ELIST -> ELIST [1944:33]
22729 | | | |--EXPR -> EXPR [1944:33]
22730 | | | | `--STRING_LITERAL -> "throwsIndent" [1944:33]
22731 | | | |--COMMA -> , [1944:47]
22732 | | | `--EXPR -> EXPR [1944:49]
22733 | | | `--STRING_LITERAL -> "8" [1944:49]
22734 | | `--RPAREN -> ) [1944:52]
22735 | |--SEMI -> ; [1944:53]
22736 | |--VARIABLE_DEF -> VARIABLE_DEF [1945:8]
22737 | | |--MODIFIERS -> MODIFIERS [1945:8]
22738 | | | `--FINAL -> final [1945:8]
22739 | | |--TYPE -> TYPE [1945:20]
22740 | | | `--ARRAY_DECLARATOR -> [ [1945:20]
22741 | | | |--IDENT -> String [1945:14]
22742 | | | `--RBRACK -> ] [1945:21]
22743 | | |--IDENT -> expected [1945:23]
22744 | | `--ASSIGN -> = [1945:32]
22745 | | `--EXPR -> EXPR [1945:44]
22746 | | `--DOT -> . [1945:44]
22747 | | |--IDENT -> CommonUtil [1945:34]
22748 | | `--IDENT -> EMPTY_STRING_ARRAY [1945:45]
22749 | |--SEMI -> ; [1945:63]
22750 | |--EXPR -> EXPR [1946:19]
22751 | | `--METHOD_CALL -> ( [1946:19]
22752 | | |--IDENT -> verifyWarns [1946:8]
22753 | | |--ELIST -> ELIST [1946:20]
22754 | | | |--EXPR -> EXPR [1946:20]
22755 | | | | `--IDENT -> checkConfig [1946:20]
22756 | | | |--COMMA -> , [1946:31]
22757 | | | |--EXPR -> EXPR [1946:40]
22758 | | | | `--METHOD_CALL -> ( [1946:40]
22759 | | | | |--IDENT -> getPath [1946:33]
22760 | | | | |--ELIST -> ELIST [1946:41]
22761 | | | | | `--EXPR -> EXPR [1946:41]
22762 | | | | | `--STRING_LITERAL -> "InputIndentationInvalidThrowsIndent.java" [1946:41]
22763 | | | | `--RPAREN -> ) [1946:83]
22764 | | | |--COMMA -> , [1946:84]
22765 | | | `--EXPR -> EXPR [1946:86]
22766 | | | `--IDENT -> expected [1946:86]
22767 | | `--RPAREN -> ) [1946:94]
22768 | |--SEMI -> ; [1946:95]
22769 | `--RCURLY -> } [1947:4]
22770 |--METHOD_DEF -> METHOD_DEF [1949:4]
22771 | |--MODIFIERS -> MODIFIERS [1949:4]
22772 | | |--ANNOTATION -> ANNOTATION [1949:4]
22773 | | | |--AT -> @ [1949:4]
22774 | | | `--IDENT -> Test [1949:5]
22775 | | `--LITERAL_PUBLIC -> public [1950:4]
22776 | |--TYPE -> TYPE [1950:11]
22777 | | `--LITERAL_VOID -> void [1950:11]
22778 | |--IDENT -> testThrowsIndentationLevel2 [1950:16]
22779 | |--LPAREN -> ( [1950:43]
22780 | |--PARAMETERS -> PARAMETERS [1950:44]
22781 | |--RPAREN -> ) [1950:44]
22782 | |--LITERAL_THROWS -> throws [1950:46]
22783 | | `--IDENT -> Exception [1950:53]
22784 | `--SLIST -> { [1950:63]
22785 | |--VARIABLE_DEF -> VARIABLE_DEF [1951:8]
22786 | | |--MODIFIERS -> MODIFIERS [1951:8]
22787 | | | `--FINAL -> final [1951:8]
22788 | | |--TYPE -> TYPE [1951:14]
22789 | | | `--IDENT -> DefaultConfiguration [1951:14]
22790 | | |--IDENT -> checkConfig [1951:35]
22791 | | `--ASSIGN -> = [1951:47]
22792 | | `--EXPR -> EXPR [1951:67]
22793 | | `--METHOD_CALL -> ( [1951:67]
22794 | | |--IDENT -> createModuleConfig [1951:49]
22795 | | |--ELIST -> ELIST [1951:84]
22796 | | | `--EXPR -> EXPR [1951:84]
22797 | | | `--DOT -> . [1951:84]
22798 | | | |--IDENT -> IndentationCheck [1951:68]
22799 | | | `--LITERAL_CLASS -> class [1951:85]
22800 | | `--RPAREN -> ) [1951:90]
22801 | |--SEMI -> ; [1951:91]
22802 | |--EXPR -> EXPR [1953:32]
22803 | | `--METHOD_CALL -> ( [1953:32]
22804 | | |--DOT -> . [1953:19]
22805 | | | |--IDENT -> checkConfig [1953:8]
22806 | | | `--IDENT -> addAttribute [1953:20]
22807 | | |--ELIST -> ELIST [1953:33]
22808 | | | |--EXPR -> EXPR [1953:33]
22809 | | | | `--STRING_LITERAL -> "basicOffset" [1953:33]
22810 | | | |--COMMA -> , [1953:46]
22811 | | | `--EXPR -> EXPR [1953:48]
22812 | | | `--STRING_LITERAL -> "1" [1953:48]
22813 | | `--RPAREN -> ) [1953:51]
22814 | |--SEMI -> ; [1953:52]
22815 | |--EXPR -> EXPR [1954:32]
22816 | | `--METHOD_CALL -> ( [1954:32]
22817 | | |--DOT -> . [1954:19]
22818 | | | |--IDENT -> checkConfig [1954:8]
22819 | | | `--IDENT -> addAttribute [1954:20]
22820 | | |--ELIST -> ELIST [1954:33]
22821 | | | |--EXPR -> EXPR [1954:33]
22822 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1954:33]
22823 | | | |--COMMA -> , [1954:55]
22824 | | | `--EXPR -> EXPR [1954:57]
22825 | | | `--STRING_LITERAL -> "true" [1954:57]
22826 | | `--RPAREN -> ) [1954:63]
22827 | |--SEMI -> ; [1954:64]
22828 | |--EXPR -> EXPR [1955:32]
22829 | | `--METHOD_CALL -> ( [1955:32]
22830 | | |--DOT -> . [1955:19]
22831 | | | |--IDENT -> checkConfig [1955:8]
22832 | | | `--IDENT -> addAttribute [1955:20]
22833 | | |--ELIST -> ELIST [1955:33]
22834 | | | |--EXPR -> EXPR [1955:33]
22835 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1955:33]
22836 | | | |--COMMA -> , [1955:58]
22837 | | | `--EXPR -> EXPR [1955:60]
22838 | | | `--STRING_LITERAL -> "3" [1955:60]
22839 | | `--RPAREN -> ) [1955:63]
22840 | |--SEMI -> ; [1955:64]
22841 | |--EXPR -> EXPR [1956:32]
22842 | | `--METHOD_CALL -> ( [1956:32]
22843 | | |--DOT -> . [1956:19]
22844 | | | |--IDENT -> checkConfig [1956:8]
22845 | | | `--IDENT -> addAttribute [1956:20]
22846 | | |--ELIST -> ELIST [1956:33]
22847 | | | |--EXPR -> EXPR [1956:33]
22848 | | | | `--STRING_LITERAL -> "tabWidth" [1956:33]
22849 | | | |--COMMA -> , [1956:43]
22850 | | | `--EXPR -> EXPR [1956:45]
22851 | | | `--STRING_LITERAL -> "4" [1956:45]
22852 | | `--RPAREN -> ) [1956:48]
22853 | |--SEMI -> ; [1956:49]
22854 | |--EXPR -> EXPR [1957:32]
22855 | | `--METHOD_CALL -> ( [1957:32]
22856 | | |--DOT -> . [1957:19]
22857 | | | |--IDENT -> checkConfig [1957:8]
22858 | | | `--IDENT -> addAttribute [1957:20]
22859 | | |--ELIST -> ELIST [1957:33]
22860 | | | |--EXPR -> EXPR [1957:33]
22861 | | | | `--STRING_LITERAL -> "throwsIndent" [1957:33]
22862 | | | |--COMMA -> , [1957:47]
22863 | | | `--EXPR -> EXPR [1957:49]
22864 | | | `--STRING_LITERAL -> "5" [1957:49]
22865 | | `--RPAREN -> ) [1957:52]
22866 | |--SEMI -> ; [1957:53]
22867 | |--VARIABLE_DEF -> VARIABLE_DEF [1958:8]
22868 | | |--MODIFIERS -> MODIFIERS [1958:8]
22869 | | | `--FINAL -> final [1958:8]
22870 | | |--TYPE -> TYPE [1958:20]
22871 | | | `--ARRAY_DECLARATOR -> [ [1958:20]
22872 | | | |--IDENT -> String [1958:14]
22873 | | | `--RBRACK -> ] [1958:21]
22874 | | |--IDENT -> expected [1958:23]
22875 | | `--ASSIGN -> = [1958:32]
22876 | | `--ARRAY_INIT -> { [1958:34]
22877 | | |--EXPR -> EXPR [1959:20]
22878 | | | `--PLUS -> + [1959:20]
22879 | | | |--STRING_LITERAL -> "7:1: " [1959:12]
22880 | | | `--METHOD_CALL -> ( [1959:37]
22881 | | | |--IDENT -> getCheckMessage [1959:22]
22882 | | | |--ELIST -> ELIST [1959:38]
22883 | | | | |--EXPR -> EXPR [1959:38]
22884 | | | | | `--IDENT -> MSG_ERROR [1959:38]
22885 | | | | |--COMMA -> , [1959:47]
22886 | | | | |--EXPR -> EXPR [1959:49]
22887 | | | | | `--STRING_LITERAL -> "Exception" [1959:49]
22888 | | | | |--COMMA -> , [1959:60]
22889 | | | | |--EXPR -> EXPR [1959:62]
22890 | | | | | `--NUM_INT -> 0 [1959:62]
22891 | | | | |--COMMA -> , [1959:63]
22892 | | | | `--EXPR -> EXPR [1959:65]
22893 | | | | `--NUM_INT -> 6 [1959:65]
22894 | | | `--RPAREN -> ) [1959:66]
22895 | | |--COMMA -> , [1959:67]
22896 | | |--EXPR -> EXPR [1960:21]
22897 | | | `--PLUS -> + [1960:21]
22898 | | | |--STRING_LITERAL -> "10:1: " [1960:12]
22899 | | | `--METHOD_CALL -> ( [1960:38]
22900 | | | |--IDENT -> getCheckMessage [1960:23]
22901 | | | |--ELIST -> ELIST [1960:39]
22902 | | | | |--EXPR -> EXPR [1960:39]
22903 | | | | | `--IDENT -> MSG_ERROR [1960:39]
22904 | | | | |--COMMA -> , [1960:48]
22905 | | | | |--EXPR -> EXPR [1960:50]
22906 | | | | | `--STRING_LITERAL -> "NullPointerException" [1960:50]
22907 | | | | |--COMMA -> , [1960:72]
22908 | | | | |--EXPR -> EXPR [1960:74]
22909 | | | | | `--NUM_INT -> 0 [1960:74]
22910 | | | | |--COMMA -> , [1960:75]
22911 | | | | `--EXPR -> EXPR [1960:77]
22912 | | | | `--NUM_INT -> 6 [1960:77]
22913 | | | `--RPAREN -> ) [1960:78]
22914 | | |--COMMA -> , [1960:79]
22915 | | |--EXPR -> EXPR [1961:21]
22916 | | | `--PLUS -> + [1961:21]
22917 | | | |--STRING_LITERAL -> "13:1: " [1961:12]
22918 | | | `--METHOD_CALL -> ( [1961:38]
22919 | | | |--IDENT -> getCheckMessage [1961:23]
22920 | | | |--ELIST -> ELIST [1961:39]
22921 | | | | |--EXPR -> EXPR [1961:39]
22922 | | | | | `--IDENT -> MSG_ERROR [1961:39]
22923 | | | | |--COMMA -> , [1961:48]
22924 | | | | |--EXPR -> EXPR [1961:50]
22925 | | | | | `--STRING_LITERAL -> "throws" [1961:50]
22926 | | | | |--COMMA -> , [1961:58]
22927 | | | | |--EXPR -> EXPR [1961:60]
22928 | | | | | `--NUM_INT -> 0 [1961:60]
22929 | | | | |--COMMA -> , [1961:61]
22930 | | | | `--EXPR -> EXPR [1961:63]
22931 | | | | `--NUM_INT -> 6 [1961:63]
22932 | | | `--RPAREN -> ) [1961:64]
22933 | | |--COMMA -> , [1961:65]
22934 | | |--EXPR -> EXPR [1962:21]
22935 | | | `--PLUS -> + [1962:21]
22936 | | | |--STRING_LITERAL -> "16:1: " [1962:12]
22937 | | | `--METHOD_CALL -> ( [1962:38]
22938 | | | |--IDENT -> getCheckMessage [1962:23]
22939 | | | |--ELIST -> ELIST [1962:39]
22940 | | | | |--EXPR -> EXPR [1962:39]
22941 | | | | | `--IDENT -> MSG_ERROR [1962:39]
22942 | | | | |--COMMA -> , [1962:48]
22943 | | | | |--EXPR -> EXPR [1962:50]
22944 | | | | | `--STRING_LITERAL -> "throws" [1962:50]
22945 | | | | |--COMMA -> , [1962:58]
22946 | | | | |--EXPR -> EXPR [1962:60]
22947 | | | | | `--NUM_INT -> 0 [1962:60]
22948 | | | | |--COMMA -> , [1962:61]
22949 | | | | `--EXPR -> EXPR [1962:63]
22950 | | | | `--NUM_INT -> 6 [1962:63]
22951 | | | `--RPAREN -> ) [1962:64]
22952 | | |--COMMA -> , [1962:65]
22953 | | |--EXPR -> EXPR [1963:21]
22954 | | | `--PLUS -> + [1963:21]
22955 | | | |--STRING_LITERAL -> "18:1: " [1963:12]
22956 | | | `--METHOD_CALL -> ( [1963:38]
22957 | | | |--IDENT -> getCheckMessage [1963:23]
22958 | | | |--ELIST -> ELIST [1963:39]
22959 | | | | |--EXPR -> EXPR [1963:39]
22960 | | | | | `--IDENT -> MSG_ERROR [1963:39]
22961 | | | | |--COMMA -> , [1963:48]
22962 | | | | |--EXPR -> EXPR [1963:50]
22963 | | | | | `--STRING_LITERAL -> "throws" [1963:50]
22964 | | | | |--COMMA -> , [1963:58]
22965 | | | | |--EXPR -> EXPR [1963:60]
22966 | | | | | `--NUM_INT -> 0 [1963:60]
22967 | | | | |--COMMA -> , [1963:61]
22968 | | | | `--EXPR -> EXPR [1963:63]
22969 | | | | `--NUM_INT -> 6 [1963:63]
22970 | | | `--RPAREN -> ) [1963:64]
22971 | | |--COMMA -> , [1963:65]
22972 | | |--EXPR -> EXPR [1964:21]
22973 | | | `--PLUS -> + [1964:21]
22974 | | | |--STRING_LITERAL -> "19:1: " [1964:12]
22975 | | | `--METHOD_CALL -> ( [1964:38]
22976 | | | |--IDENT -> getCheckMessage [1964:23]
22977 | | | |--ELIST -> ELIST [1964:39]
22978 | | | | |--EXPR -> EXPR [1964:39]
22979 | | | | | `--IDENT -> MSG_ERROR [1964:39]
22980 | | | | |--COMMA -> , [1964:48]
22981 | | | | |--EXPR -> EXPR [1964:50]
22982 | | | | | `--STRING_LITERAL -> "Exception" [1964:50]
22983 | | | | |--COMMA -> , [1964:61]
22984 | | | | |--EXPR -> EXPR [1964:63]
22985 | | | | | `--NUM_INT -> 0 [1964:63]
22986 | | | | |--COMMA -> , [1964:64]
22987 | | | | `--EXPR -> EXPR [1964:66]
22988 | | | | `--NUM_INT -> 6 [1964:66]
22989 | | | `--RPAREN -> ) [1964:67]
22990 | | |--COMMA -> , [1964:68]
22991 | | |--EXPR -> EXPR [1965:21]
22992 | | | `--PLUS -> + [1965:21]
22993 | | | |--STRING_LITERAL -> "22:1: " [1965:12]
22994 | | | `--METHOD_CALL -> ( [1965:38]
22995 | | | |--IDENT -> getCheckMessage [1965:23]
22996 | | | |--ELIST -> ELIST [1965:39]
22997 | | | | |--EXPR -> EXPR [1965:39]
22998 | | | | | `--IDENT -> MSG_ERROR [1965:39]
22999 | | | | |--COMMA -> , [1965:48]
23000 | | | | |--EXPR -> EXPR [1965:50]
23001 | | | | | `--STRING_LITERAL -> "throws" [1965:50]
23002 | | | | |--COMMA -> , [1965:58]
23003 | | | | |--EXPR -> EXPR [1965:60]
23004 | | | | | `--NUM_INT -> 0 [1965:60]
23005 | | | | |--COMMA -> , [1965:61]
23006 | | | | `--EXPR -> EXPR [1965:63]
23007 | | | | `--NUM_INT -> 6 [1965:63]
23008 | | | `--RPAREN -> ) [1965:64]
23009 | | |--COMMA -> , [1965:65]
23010 | | |--EXPR -> EXPR [1966:21]
23011 | | | `--PLUS -> + [1966:21]
23012 | | | |--STRING_LITERAL -> "23:1: " [1966:12]
23013 | | | `--METHOD_CALL -> ( [1966:38]
23014 | | | |--IDENT -> getCheckMessage [1966:23]
23015 | | | |--ELIST -> ELIST [1966:39]
23016 | | | | |--EXPR -> EXPR [1966:39]
23017 | | | | | `--IDENT -> MSG_ERROR [1966:39]
23018 | | | | |--COMMA -> , [1966:48]
23019 | | | | |--EXPR -> EXPR [1966:50]
23020 | | | | | `--STRING_LITERAL -> "Exception" [1966:50]
23021 | | | | |--COMMA -> , [1966:61]
23022 | | | | |--EXPR -> EXPR [1966:63]
23023 | | | | | `--NUM_INT -> 0 [1966:63]
23024 | | | | |--COMMA -> , [1966:64]
23025 | | | | `--EXPR -> EXPR [1966:66]
23026 | | | | `--NUM_INT -> 6 [1966:66]
23027 | | | `--RPAREN -> ) [1966:67]
23028 | | |--COMMA -> , [1966:68]
23029 | | |--EXPR -> EXPR [1967:21]
23030 | | | `--PLUS -> + [1967:21]
23031 | | | |--STRING_LITERAL -> "24:1: " [1967:12]
23032 | | | `--METHOD_CALL -> ( [1967:38]
23033 | | | |--IDENT -> getCheckMessage [1967:23]
23034 | | | |--ELIST -> ELIST [1967:39]
23035 | | | | |--EXPR -> EXPR [1967:39]
23036 | | | | | `--IDENT -> MSG_ERROR [1967:39]
23037 | | | | |--COMMA -> , [1967:48]
23038 | | | | |--EXPR -> EXPR [1967:50]
23039 | | | | | `--STRING_LITERAL -> "NullPointerException" [1967:50]
23040 | | | | |--COMMA -> , [1967:72]
23041 | | | | |--EXPR -> EXPR [1967:74]
23042 | | | | | `--NUM_INT -> 0 [1967:74]
23043 | | | | |--COMMA -> , [1967:75]
23044 | | | | `--EXPR -> EXPR [1967:77]
23045 | | | | `--NUM_INT -> 6 [1967:77]
23046 | | | `--RPAREN -> ) [1967:78]
23047 | | |--COMMA -> , [1967:79]
23048 | | |--EXPR -> EXPR [1968:21]
23049 | | | `--PLUS -> + [1968:21]
23050 | | | |--STRING_LITERAL -> "27:1: " [1968:12]
23051 | | | `--METHOD_CALL -> ( [1968:38]
23052 | | | |--IDENT -> getCheckMessage [1968:23]
23053 | | | |--ELIST -> ELIST [1968:39]
23054 | | | | |--EXPR -> EXPR [1968:39]
23055 | | | | | `--IDENT -> MSG_ERROR [1968:39]
23056 | | | | |--COMMA -> , [1968:48]
23057 | | | | |--EXPR -> EXPR [1968:50]
23058 | | | | | `--STRING_LITERAL -> "throws" [1968:50]
23059 | | | | |--COMMA -> , [1968:58]
23060 | | | | |--EXPR -> EXPR [1968:60]
23061 | | | | | `--NUM_INT -> 0 [1968:60]
23062 | | | | |--COMMA -> , [1968:61]
23063 | | | | `--EXPR -> EXPR [1968:63]
23064 | | | | `--NUM_INT -> 6 [1968:63]
23065 | | | `--RPAREN -> ) [1968:64]
23066 | | |--COMMA -> , [1968:65]
23067 | | |--EXPR -> EXPR [1969:21]
23068 | | | `--PLUS -> + [1969:21]
23069 | | | |--STRING_LITERAL -> "28:1: " [1969:12]
23070 | | | `--METHOD_CALL -> ( [1969:38]
23071 | | | |--IDENT -> getCheckMessage [1969:23]
23072 | | | |--ELIST -> ELIST [1969:39]
23073 | | | | |--EXPR -> EXPR [1969:39]
23074 | | | | | `--IDENT -> MSG_ERROR [1969:39]
23075 | | | | |--COMMA -> , [1969:48]
23076 | | | | |--EXPR -> EXPR [1969:50]
23077 | | | | | `--STRING_LITERAL -> "Exception" [1969:50]
23078 | | | | |--COMMA -> , [1969:61]
23079 | | | | |--EXPR -> EXPR [1969:63]
23080 | | | | | `--NUM_INT -> 0 [1969:63]
23081 | | | | |--COMMA -> , [1969:64]
23082 | | | | `--EXPR -> EXPR [1969:66]
23083 | | | | `--NUM_INT -> 6 [1969:66]
23084 | | | `--RPAREN -> ) [1969:67]
23085 | | |--COMMA -> , [1969:68]
23086 | | |--EXPR -> EXPR [1970:21]
23087 | | | `--PLUS -> + [1970:21]
23088 | | | |--STRING_LITERAL -> "31:1: " [1970:12]
23089 | | | `--METHOD_CALL -> ( [1970:38]
23090 | | | |--IDENT -> getCheckMessage [1970:23]
23091 | | | |--ELIST -> ELIST [1970:39]
23092 | | | | |--EXPR -> EXPR [1970:39]
23093 | | | | | `--IDENT -> MSG_ERROR [1970:39]
23094 | | | | |--COMMA -> , [1970:48]
23095 | | | | |--EXPR -> EXPR [1970:50]
23096 | | | | | `--STRING_LITERAL -> "throws" [1970:50]
23097 | | | | |--COMMA -> , [1970:58]
23098 | | | | |--EXPR -> EXPR [1970:60]
23099 | | | | | `--NUM_INT -> 0 [1970:60]
23100 | | | | |--COMMA -> , [1970:61]
23101 | | | | `--EXPR -> EXPR [1970:63]
23102 | | | | `--NUM_INT -> 6 [1970:63]
23103 | | | `--RPAREN -> ) [1970:64]
23104 | | |--COMMA -> , [1970:65]
23105 | | |--EXPR -> EXPR [1971:21]
23106 | | | `--PLUS -> + [1971:21]
23107 | | | |--STRING_LITERAL -> "37:1: " [1971:12]
23108 | | | `--METHOD_CALL -> ( [1971:38]
23109 | | | |--IDENT -> getCheckMessage [1971:23]
23110 | | | |--ELIST -> ELIST [1971:39]
23111 | | | | |--EXPR -> EXPR [1971:39]
23112 | | | | | `--IDENT -> MSG_ERROR [1971:39]
23113 | | | | |--COMMA -> , [1971:48]
23114 | | | | |--EXPR -> EXPR [1971:50]
23115 | | | | | `--STRING_LITERAL -> "throws" [1971:50]
23116 | | | | |--COMMA -> , [1971:58]
23117 | | | | |--EXPR -> EXPR [1971:60]
23118 | | | | | `--NUM_INT -> 0 [1971:60]
23119 | | | | |--COMMA -> , [1971:61]
23120 | | | | `--EXPR -> EXPR [1971:63]
23121 | | | | `--NUM_INT -> 6 [1971:63]
23122 | | | `--RPAREN -> ) [1971:64]
23123 | | |--COMMA -> , [1971:65]
23124 | | `--RCURLY -> } [1972:8]
23125 | |--SEMI -> ; [1972:9]
23126 | |--EXPR -> EXPR [1973:19]
23127 | | `--METHOD_CALL -> ( [1973:19]
23128 | | |--IDENT -> verifyWarns [1973:8]
23129 | | |--ELIST -> ELIST [1973:20]
23130 | | | |--EXPR -> EXPR [1973:20]
23131 | | | | `--IDENT -> checkConfig [1973:20]
23132 | | | |--COMMA -> , [1973:31]
23133 | | | |--EXPR -> EXPR [1973:40]
23134 | | | | `--METHOD_CALL -> ( [1973:40]
23135 | | | | |--IDENT -> getPath [1973:33]
23136 | | | | |--ELIST -> ELIST [1973:41]
23137 | | | | | `--EXPR -> EXPR [1973:41]
23138 | | | | | `--STRING_LITERAL -> "InputIndentationInvalidThrowsIndent2.java" [1973:41]
23139 | | | | `--RPAREN -> ) [1973:84]
23140 | | | |--COMMA -> , [1973:85]
23141 | | | `--EXPR -> EXPR [1973:87]
23142 | | | `--IDENT -> expected [1973:87]
23143 | | `--RPAREN -> ) [1973:95]
23144 | |--SEMI -> ; [1973:96]
23145 | `--RCURLY -> } [1974:4]
23146 |--METHOD_DEF -> METHOD_DEF [1976:4]
23147 | |--MODIFIERS -> MODIFIERS [1976:4]
23148 | | |--ANNOTATION -> ANNOTATION [1976:4]
23149 | | | |--AT -> @ [1976:4]
23150 | | | `--IDENT -> Test [1976:5]
23151 | | `--LITERAL_PUBLIC -> public [1977:4]
23152 | |--TYPE -> TYPE [1977:11]
23153 | | `--LITERAL_VOID -> void [1977:11]
23154 | |--IDENT -> testCaseLevel [1977:16]
23155 | |--LPAREN -> ( [1977:29]
23156 | |--PARAMETERS -> PARAMETERS [1977:30]
23157 | |--RPAREN -> ) [1977:30]
23158 | |--LITERAL_THROWS -> throws [1977:32]
23159 | | `--IDENT -> Exception [1977:39]
23160 | `--SLIST -> { [1977:49]
23161 | |--VARIABLE_DEF -> VARIABLE_DEF [1978:8]
23162 | | |--MODIFIERS -> MODIFIERS [1978:8]
23163 | | | `--FINAL -> final [1978:8]
23164 | | |--TYPE -> TYPE [1978:14]
23165 | | | `--IDENT -> DefaultConfiguration [1978:14]
23166 | | |--IDENT -> checkConfig [1978:35]
23167 | | `--ASSIGN -> = [1978:47]
23168 | | `--EXPR -> EXPR [1978:67]
23169 | | `--METHOD_CALL -> ( [1978:67]
23170 | | |--IDENT -> createModuleConfig [1978:49]
23171 | | |--ELIST -> ELIST [1978:84]
23172 | | | `--EXPR -> EXPR [1978:84]
23173 | | | `--DOT -> . [1978:84]
23174 | | | |--IDENT -> IndentationCheck [1978:68]
23175 | | | `--LITERAL_CLASS -> class [1978:85]
23176 | | `--RPAREN -> ) [1978:90]
23177 | |--SEMI -> ; [1978:91]
23178 | |--EXPR -> EXPR [1980:32]
23179 | | `--METHOD_CALL -> ( [1980:32]
23180 | | |--DOT -> . [1980:19]
23181 | | | |--IDENT -> checkConfig [1980:8]
23182 | | | `--IDENT -> addAttribute [1980:20]
23183 | | |--ELIST -> ELIST [1980:33]
23184 | | | |--EXPR -> EXPR [1980:33]
23185 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1980:33]
23186 | | | |--COMMA -> , [1980:50]
23187 | | | `--EXPR -> EXPR [1980:52]
23188 | | | `--STRING_LITERAL -> "4" [1980:52]
23189 | | `--RPAREN -> ) [1980:55]
23190 | |--SEMI -> ; [1980:56]
23191 | |--EXPR -> EXPR [1981:32]
23192 | | `--METHOD_CALL -> ( [1981:32]
23193 | | |--DOT -> . [1981:19]
23194 | | | |--IDENT -> checkConfig [1981:8]
23195 | | | `--IDENT -> addAttribute [1981:20]
23196 | | |--ELIST -> ELIST [1981:33]
23197 | | | |--EXPR -> EXPR [1981:33]
23198 | | | | `--STRING_LITERAL -> "basicOffset" [1981:33]
23199 | | | |--COMMA -> , [1981:46]
23200 | | | `--EXPR -> EXPR [1981:48]
23201 | | | `--STRING_LITERAL -> "4" [1981:48]
23202 | | `--RPAREN -> ) [1981:51]
23203 | |--SEMI -> ; [1981:52]
23204 | |--EXPR -> EXPR [1982:32]
23205 | | `--METHOD_CALL -> ( [1982:32]
23206 | | |--DOT -> . [1982:19]
23207 | | | |--IDENT -> checkConfig [1982:8]
23208 | | | `--IDENT -> addAttribute [1982:20]
23209 | | |--ELIST -> ELIST [1982:33]
23210 | | | |--EXPR -> EXPR [1982:33]
23211 | | | | `--STRING_LITERAL -> "braceAdjustment" [1982:33]
23212 | | | |--COMMA -> , [1982:50]
23213 | | | `--EXPR -> EXPR [1982:52]
23214 | | | `--STRING_LITERAL -> "0" [1982:52]
23215 | | `--RPAREN -> ) [1982:55]
23216 | |--SEMI -> ; [1982:56]
23217 | |--EXPR -> EXPR [1983:32]
23218 | | `--METHOD_CALL -> ( [1983:32]
23219 | | |--DOT -> . [1983:19]
23220 | | | |--IDENT -> checkConfig [1983:8]
23221 | | | `--IDENT -> addAttribute [1983:20]
23222 | | |--ELIST -> ELIST [1983:33]
23223 | | | |--EXPR -> EXPR [1983:33]
23224 | | | | `--STRING_LITERAL -> "caseIndent" [1983:33]
23225 | | | |--COMMA -> , [1983:45]
23226 | | | `--EXPR -> EXPR [1983:47]
23227 | | | `--STRING_LITERAL -> "0" [1983:47]
23228 | | `--RPAREN -> ) [1983:50]
23229 | |--SEMI -> ; [1983:51]
23230 | |--EXPR -> EXPR [1984:32]
23231 | | `--METHOD_CALL -> ( [1984:32]
23232 | | |--DOT -> . [1984:19]
23233 | | | |--IDENT -> checkConfig [1984:8]
23234 | | | `--IDENT -> addAttribute [1984:20]
23235 | | |--ELIST -> ELIST [1984:33]
23236 | | | |--EXPR -> EXPR [1984:33]
23237 | | | | `--STRING_LITERAL -> "forceStrictCondition" [1984:33]
23238 | | | |--COMMA -> , [1984:55]
23239 | | | `--EXPR -> EXPR [1984:57]
23240 | | | `--STRING_LITERAL -> "false" [1984:57]
23241 | | `--RPAREN -> ) [1984:64]
23242 | |--SEMI -> ; [1984:65]
23243 | |--EXPR -> EXPR [1985:32]
23244 | | `--METHOD_CALL -> ( [1985:32]
23245 | | |--DOT -> . [1985:19]
23246 | | | |--IDENT -> checkConfig [1985:8]
23247 | | | `--IDENT -> addAttribute [1985:20]
23248 | | |--ELIST -> ELIST [1985:33]
23249 | | | |--EXPR -> EXPR [1985:33]
23250 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [1985:33]
23251 | | | |--COMMA -> , [1985:58]
23252 | | | `--EXPR -> EXPR [1985:60]
23253 | | | `--STRING_LITERAL -> "4" [1985:60]
23254 | | `--RPAREN -> ) [1985:63]
23255 | |--SEMI -> ; [1985:64]
23256 | |--EXPR -> EXPR [1986:32]
23257 | | `--METHOD_CALL -> ( [1986:32]
23258 | | |--DOT -> . [1986:19]
23259 | | | |--IDENT -> checkConfig [1986:8]
23260 | | | `--IDENT -> addAttribute [1986:20]
23261 | | |--ELIST -> ELIST [1986:33]
23262 | | | |--EXPR -> EXPR [1986:33]
23263 | | | | `--STRING_LITERAL -> "tabWidth" [1986:33]
23264 | | | |--COMMA -> , [1986:43]
23265 | | | `--EXPR -> EXPR [1986:45]
23266 | | | `--STRING_LITERAL -> "4" [1986:45]
23267 | | `--RPAREN -> ) [1986:48]
23268 | |--SEMI -> ; [1986:49]
23269 | |--EXPR -> EXPR [1987:32]
23270 | | `--METHOD_CALL -> ( [1987:32]
23271 | | |--DOT -> . [1987:19]
23272 | | | |--IDENT -> checkConfig [1987:8]
23273 | | | `--IDENT -> addAttribute [1987:20]
23274 | | |--ELIST -> ELIST [1987:33]
23275 | | | |--EXPR -> EXPR [1987:33]
23276 | | | | `--STRING_LITERAL -> "throwsIndent" [1987:33]
23277 | | | |--COMMA -> , [1987:47]
23278 | | | `--EXPR -> EXPR [1987:49]
23279 | | | `--STRING_LITERAL -> "4" [1987:49]
23280 | | `--RPAREN -> ) [1987:52]
23281 | |--SEMI -> ; [1987:53]
23282 | |--VARIABLE_DEF -> VARIABLE_DEF [1988:8]
23283 | | |--MODIFIERS -> MODIFIERS [1988:8]
23284 | | | `--FINAL -> final [1988:8]
23285 | | |--TYPE -> TYPE [1988:20]
23286 | | | `--ARRAY_DECLARATOR -> [ [1988:20]
23287 | | | |--IDENT -> String [1988:14]
23288 | | | `--RBRACK -> ] [1988:21]
23289 | | |--IDENT -> expected [1988:23]
23290 | | `--ASSIGN -> = [1988:32]
23291 | | `--ARRAY_INIT -> { [1988:34]
23292 | | |--EXPR -> EXPR [1989:22]
23293 | | | `--PLUS -> + [1989:22]
23294 | | | |--STRING_LITERAL -> "27:11: " [1989:12]
23295 | | | `--METHOD_CALL -> ( [1989:39]
23296 | | | |--IDENT -> getCheckMessage [1989:24]
23297 | | | |--ELIST -> ELIST [1989:40]
23298 | | | | |--EXPR -> EXPR [1989:40]
23299 | | | | | `--IDENT -> MSG_CHILD_ERROR [1989:40]
23300 | | | | |--COMMA -> , [1989:55]
23301 | | | | |--EXPR -> EXPR [1989:57]
23302 | | | | | `--STRING_LITERAL -> "case" [1989:57]
23303 | | | | |--COMMA -> , [1989:63]
23304 | | | | |--EXPR -> EXPR [1989:65]
23305 | | | | | `--NUM_INT -> 10 [1989:65]
23306 | | | | |--COMMA -> , [1989:67]
23307 | | | | `--EXPR -> EXPR [1989:69]
23308 | | | | `--NUM_INT -> 8 [1989:69]
23309 | | | `--RPAREN -> ) [1989:70]
23310 | | |--COMMA -> , [1989:71]
23311 | | `--RCURLY -> } [1990:8]
23312 | |--SEMI -> ; [1990:9]
23313 | |--EXPR -> EXPR [1991:19]
23314 | | `--METHOD_CALL -> ( [1991:19]
23315 | | |--IDENT -> verifyWarns [1991:8]
23316 | | |--ELIST -> ELIST [1991:20]
23317 | | | |--EXPR -> EXPR [1991:20]
23318 | | | | `--IDENT -> checkConfig [1991:20]
23319 | | | |--COMMA -> , [1991:31]
23320 | | | |--EXPR -> EXPR [1991:40]
23321 | | | | `--METHOD_CALL -> ( [1991:40]
23322 | | | | |--IDENT -> getPath [1991:33]
23323 | | | | |--ELIST -> ELIST [1991:41]
23324 | | | | | `--EXPR -> EXPR [1991:41]
23325 | | | | | `--STRING_LITERAL -> "InputIndentationCaseLevel.java" [1991:41]
23326 | | | | `--RPAREN -> ) [1991:73]
23327 | | | |--COMMA -> , [1991:74]
23328 | | | `--EXPR -> EXPR [1991:76]
23329 | | | `--IDENT -> expected [1991:76]
23330 | | `--RPAREN -> ) [1991:84]
23331 | |--SEMI -> ; [1991:85]
23332 | `--RCURLY -> } [1992:4]
23333 |--METHOD_DEF -> METHOD_DEF [1994:4]
23334 | |--MODIFIERS -> MODIFIERS [1994:4]
23335 | | |--ANNOTATION -> ANNOTATION [1994:4]
23336 | | | |--AT -> @ [1994:4]
23337 | | | `--IDENT -> Test [1994:5]
23338 | | `--LITERAL_PUBLIC -> public [1995:4]
23339 | |--TYPE -> TYPE [1995:11]
23340 | | `--LITERAL_VOID -> void [1995:11]
23341 | |--IDENT -> testBraceAdjustment [1995:16]
23342 | |--LPAREN -> ( [1995:35]
23343 | |--PARAMETERS -> PARAMETERS [1995:36]
23344 | |--RPAREN -> ) [1995:36]
23345 | |--LITERAL_THROWS -> throws [1995:38]
23346 | | `--IDENT -> Exception [1995:45]
23347 | `--SLIST -> { [1995:55]
23348 | |--VARIABLE_DEF -> VARIABLE_DEF [1996:8]
23349 | | |--MODIFIERS -> MODIFIERS [1996:8]
23350 | | | `--FINAL -> final [1996:8]
23351 | | |--TYPE -> TYPE [1996:14]
23352 | | | `--IDENT -> DefaultConfiguration [1996:14]
23353 | | |--IDENT -> checkConfig [1996:35]
23354 | | `--ASSIGN -> = [1996:47]
23355 | | `--EXPR -> EXPR [1996:67]
23356 | | `--METHOD_CALL -> ( [1996:67]
23357 | | |--IDENT -> createModuleConfig [1996:49]
23358 | | |--ELIST -> ELIST [1996:84]
23359 | | | `--EXPR -> EXPR [1996:84]
23360 | | | `--DOT -> . [1996:84]
23361 | | | |--IDENT -> IndentationCheck [1996:68]
23362 | | | `--LITERAL_CLASS -> class [1996:85]
23363 | | `--RPAREN -> ) [1996:90]
23364 | |--SEMI -> ; [1996:91]
23365 | |--EXPR -> EXPR [1998:32]
23366 | | `--METHOD_CALL -> ( [1998:32]
23367 | | |--DOT -> . [1998:19]
23368 | | | |--IDENT -> checkConfig [1998:8]
23369 | | | `--IDENT -> addAttribute [1998:20]
23370 | | |--ELIST -> ELIST [1998:33]
23371 | | | |--EXPR -> EXPR [1998:33]
23372 | | | | `--STRING_LITERAL -> "arrayInitIndent" [1998:33]
23373 | | | |--COMMA -> , [1998:50]
23374 | | | `--EXPR -> EXPR [1998:52]
23375 | | | `--STRING_LITERAL -> "4" [1998:52]
23376 | | `--RPAREN -> ) [1998:55]
23377 | |--SEMI -> ; [1998:56]
23378 | |--EXPR -> EXPR [1999:32]
23379 | | `--METHOD_CALL -> ( [1999:32]
23380 | | |--DOT -> . [1999:19]
23381 | | | |--IDENT -> checkConfig [1999:8]
23382 | | | `--IDENT -> addAttribute [1999:20]
23383 | | |--ELIST -> ELIST [1999:33]
23384 | | | |--EXPR -> EXPR [1999:33]
23385 | | | | `--STRING_LITERAL -> "basicOffset" [1999:33]
23386 | | | |--COMMA -> , [1999:46]
23387 | | | `--EXPR -> EXPR [1999:48]
23388 | | | `--STRING_LITERAL -> "4" [1999:48]
23389 | | `--RPAREN -> ) [1999:51]
23390 | |--SEMI -> ; [1999:52]
23391 | |--EXPR -> EXPR [2000:32]
23392 | | `--METHOD_CALL -> ( [2000:32]
23393 | | |--DOT -> . [2000:19]
23394 | | | |--IDENT -> checkConfig [2000:8]
23395 | | | `--IDENT -> addAttribute [2000:20]
23396 | | |--ELIST -> ELIST [2000:33]
23397 | | | |--EXPR -> EXPR [2000:33]
23398 | | | | `--STRING_LITERAL -> "braceAdjustment" [2000:33]
23399 | | | |--COMMA -> , [2000:50]
23400 | | | `--EXPR -> EXPR [2000:52]
23401 | | | `--STRING_LITERAL -> "2" [2000:52]
23402 | | `--RPAREN -> ) [2000:55]
23403 | |--SEMI -> ; [2000:56]
23404 | |--EXPR -> EXPR [2001:32]
23405 | | `--METHOD_CALL -> ( [2001:32]
23406 | | |--DOT -> . [2001:19]
23407 | | | |--IDENT -> checkConfig [2001:8]
23408 | | | `--IDENT -> addAttribute [2001:20]
23409 | | |--ELIST -> ELIST [2001:33]
23410 | | | |--EXPR -> EXPR [2001:33]
23411 | | | | `--STRING_LITERAL -> "caseIndent" [2001:33]
23412 | | | |--COMMA -> , [2001:45]
23413 | | | `--EXPR -> EXPR [2001:47]
23414 | | | `--STRING_LITERAL -> "4" [2001:47]
23415 | | `--RPAREN -> ) [2001:50]
23416 | |--SEMI -> ; [2001:51]
23417 | |--EXPR -> EXPR [2002:32]
23418 | | `--METHOD_CALL -> ( [2002:32]
23419 | | |--DOT -> . [2002:19]
23420 | | | |--IDENT -> checkConfig [2002:8]
23421 | | | `--IDENT -> addAttribute [2002:20]
23422 | | |--ELIST -> ELIST [2002:33]
23423 | | | |--EXPR -> EXPR [2002:33]
23424 | | | | `--STRING_LITERAL -> "forceStrictCondition" [2002:33]
23425 | | | |--COMMA -> , [2002:55]
23426 | | | `--EXPR -> EXPR [2002:57]
23427 | | | `--STRING_LITERAL -> "false" [2002:57]
23428 | | `--RPAREN -> ) [2002:64]
23429 | |--SEMI -> ; [2002:65]
23430 | |--EXPR -> EXPR [2003:32]
23431 | | `--METHOD_CALL -> ( [2003:32]
23432 | | |--DOT -> . [2003:19]
23433 | | | |--IDENT -> checkConfig [2003:8]
23434 | | | `--IDENT -> addAttribute [2003:20]
23435 | | |--ELIST -> ELIST [2003:33]
23436 | | | |--EXPR -> EXPR [2003:33]
23437 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2003:33]
23438 | | | |--COMMA -> , [2003:58]
23439 | | | `--EXPR -> EXPR [2003:60]
23440 | | | `--STRING_LITERAL -> "4" [2003:60]
23441 | | `--RPAREN -> ) [2003:63]
23442 | |--SEMI -> ; [2003:64]
23443 | |--EXPR -> EXPR [2004:32]
23444 | | `--METHOD_CALL -> ( [2004:32]
23445 | | |--DOT -> . [2004:19]
23446 | | | |--IDENT -> checkConfig [2004:8]
23447 | | | `--IDENT -> addAttribute [2004:20]
23448 | | |--ELIST -> ELIST [2004:33]
23449 | | | |--EXPR -> EXPR [2004:33]
23450 | | | | `--STRING_LITERAL -> "tabWidth" [2004:33]
23451 | | | |--COMMA -> , [2004:43]
23452 | | | `--EXPR -> EXPR [2004:45]
23453 | | | `--STRING_LITERAL -> "4" [2004:45]
23454 | | `--RPAREN -> ) [2004:48]
23455 | |--SEMI -> ; [2004:49]
23456 | |--EXPR -> EXPR [2005:32]
23457 | | `--METHOD_CALL -> ( [2005:32]
23458 | | |--DOT -> . [2005:19]
23459 | | | |--IDENT -> checkConfig [2005:8]
23460 | | | `--IDENT -> addAttribute [2005:20]
23461 | | |--ELIST -> ELIST [2005:33]
23462 | | | |--EXPR -> EXPR [2005:33]
23463 | | | | `--STRING_LITERAL -> "throwsIndent" [2005:33]
23464 | | | |--COMMA -> , [2005:47]
23465 | | | `--EXPR -> EXPR [2005:49]
23466 | | | `--STRING_LITERAL -> "4" [2005:49]
23467 | | `--RPAREN -> ) [2005:52]
23468 | |--SEMI -> ; [2005:53]
23469 | |--VARIABLE_DEF -> VARIABLE_DEF [2006:8]
23470 | | |--MODIFIERS -> MODIFIERS [2006:8]
23471 | | | `--FINAL -> final [2006:8]
23472 | | |--TYPE -> TYPE [2006:20]
23473 | | | `--ARRAY_DECLARATOR -> [ [2006:20]
23474 | | | |--IDENT -> String [2006:14]
23475 | | | `--RBRACK -> ] [2006:21]
23476 | | |--IDENT -> expected [2006:23]
23477 | | `--ASSIGN -> = [2006:32]
23478 | | `--ARRAY_INIT -> { [2006:34]
23479 | | |--EXPR -> EXPR [2007:21]
23480 | | | `--PLUS -> + [2007:21]
23481 | | | |--STRING_LITERAL -> "24:9: " [2007:12]
23482 | | | `--METHOD_CALL -> ( [2007:38]
23483 | | | |--IDENT -> getCheckMessage [2007:23]
23484 | | | |--ELIST -> ELIST [2007:39]
23485 | | | | |--EXPR -> EXPR [2007:39]
23486 | | | | | `--IDENT -> MSG_CHILD_ERROR [2007:39]
23487 | | | | |--COMMA -> , [2007:54]
23488 | | | | |--EXPR -> EXPR [2007:56]
23489 | | | | | `--STRING_LITERAL -> "ctor def" [2007:56]
23490 | | | | |--COMMA -> , [2007:66]
23491 | | | | |--EXPR -> EXPR [2007:68]
23492 | | | | | `--NUM_INT -> 8 [2007:68]
23493 | | | | |--COMMA -> , [2007:69]
23494 | | | | `--EXPR -> EXPR [2007:71]
23495 | | | | `--NUM_INT -> 10 [2007:71]
23496 | | | `--RPAREN -> ) [2007:73]
23497 | | |--COMMA -> , [2007:74]
23498 | | |--EXPR -> EXPR [2008:21]
23499 | | | `--PLUS -> + [2008:21]
23500 | | | |--STRING_LITERAL -> "25:9: " [2008:12]
23501 | | | `--METHOD_CALL -> ( [2008:38]
23502 | | | |--IDENT -> getCheckMessage [2008:23]
23503 | | | |--ELIST -> ELIST [2008:39]
23504 | | | | |--EXPR -> EXPR [2008:39]
23505 | | | | | `--IDENT -> MSG_ERROR [2008:39]
23506 | | | | |--COMMA -> , [2008:48]
23507 | | | | |--EXPR -> EXPR [2008:50]
23508 | | | | | `--STRING_LITERAL -> "if" [2008:50]
23509 | | | | |--COMMA -> , [2008:54]
23510 | | | | |--EXPR -> EXPR [2008:56]
23511 | | | | | `--NUM_INT -> 8 [2008:56]
23512 | | | | |--COMMA -> , [2008:57]
23513 | | | | `--EXPR -> EXPR [2008:59]
23514 | | | | `--NUM_INT -> 10 [2008:59]
23515 | | | `--RPAREN -> ) [2008:61]
23516 | | |--COMMA -> , [2008:62]
23517 | | |--EXPR -> EXPR [2009:22]
23518 | | | `--PLUS -> + [2009:22]
23519 | | | |--STRING_LITERAL -> "26:11: " [2009:12]
23520 | | | `--METHOD_CALL -> ( [2009:39]
23521 | | | |--IDENT -> getCheckMessage [2009:24]
23522 | | | |--ELIST -> ELIST [2009:40]
23523 | | | | |--EXPR -> EXPR [2009:40]
23524 | | | | | `--IDENT -> MSG_ERROR [2009:40]
23525 | | | | |--COMMA -> , [2009:49]
23526 | | | | |--EXPR -> EXPR [2009:51]
23527 | | | | | `--STRING_LITERAL -> "if lcurly" [2009:51]
23528 | | | | |--COMMA -> , [2009:62]
23529 | | | | |--EXPR -> EXPR [2009:64]
23530 | | | | | `--NUM_INT -> 10 [2009:64]
23531 | | | | |--COMMA -> , [2009:66]
23532 | | | | `--EXPR -> EXPR [2009:68]
23533 | | | | `--NUM_INT -> 12 [2009:68]
23534 | | | `--RPAREN -> ) [2009:70]
23535 | | |--COMMA -> , [2009:71]
23536 | | |--EXPR -> EXPR [2010:22]
23537 | | | `--PLUS -> + [2010:22]
23538 | | | |--STRING_LITERAL -> "27:13: " [2010:12]
23539 | | | `--METHOD_CALL -> ( [2010:39]
23540 | | | |--IDENT -> getCheckMessage [2010:24]
23541 | | | |--ELIST -> ELIST [2010:40]
23542 | | | | |--EXPR -> EXPR [2010:40]
23543 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [2010:40]
23544 | | | | |--COMMA -> , [2010:61]
23545 | | | | |--EXPR -> EXPR [2010:63]
23546 | | | | | `--STRING_LITERAL -> "if" [2010:63]
23547 | | | | |--COMMA -> , [2010:67]
23548 | | | | |--EXPR -> EXPR [2010:69]
23549 | | | | | `--NUM_INT -> 12 [2010:69]
23550 | | | | |--COMMA -> , [2010:71]
23551 | | | | `--EXPR -> EXPR [2010:73]
23552 | | | | `--STRING_LITERAL -> "14, 16" [2010:73]
23553 | | | `--RPAREN -> ) [2010:81]
23554 | | |--COMMA -> , [2010:82]
23555 | | |--EXPR -> EXPR [2011:21]
23556 | | | `--PLUS -> + [2011:21]
23557 | | | |--STRING_LITERAL -> "28:9: " [2011:12]
23558 | | | `--METHOD_CALL -> ( [2011:38]
23559 | | | |--IDENT -> getCheckMessage [2011:23]
23560 | | | |--ELIST -> ELIST [2011:39]
23561 | | | | |--EXPR -> EXPR [2011:39]
23562 | | | | | `--IDENT -> MSG_ERROR [2011:39]
23563 | | | | |--COMMA -> , [2011:48]
23564 | | | | |--EXPR -> EXPR [2011:50]
23565 | | | | | `--STRING_LITERAL -> "if rcurly" [2011:50]
23566 | | | | |--COMMA -> , [2011:61]
23567 | | | | |--EXPR -> EXPR [2011:63]
23568 | | | | | `--NUM_INT -> 8 [2011:63]
23569 | | | | |--COMMA -> , [2011:64]
23570 | | | | `--EXPR -> EXPR [2011:66]
23571 | | | | `--NUM_INT -> 12 [2011:66]
23572 | | | `--RPAREN -> ) [2011:68]
23573 | | |--COMMA -> , [2011:69]
23574 | | `--RCURLY -> } [2012:8]
23575 | |--SEMI -> ; [2012:9]
23576 | |--EXPR -> EXPR [2013:19]
23577 | | `--METHOD_CALL -> ( [2013:19]
23578 | | |--IDENT -> verifyWarns [2013:8]
23579 | | |--ELIST -> ELIST [2013:20]
23580 | | | |--EXPR -> EXPR [2013:20]
23581 | | | | `--IDENT -> checkConfig [2013:20]
23582 | | | |--COMMA -> , [2013:31]
23583 | | | |--EXPR -> EXPR [2013:40]
23584 | | | | `--METHOD_CALL -> ( [2013:40]
23585 | | | | |--IDENT -> getPath [2013:33]
23586 | | | | |--ELIST -> ELIST [2013:41]
23587 | | | | | `--EXPR -> EXPR [2013:41]
23588 | | | | | `--STRING_LITERAL -> "InputIndentationBraceAdjustment.java" [2013:41]
23589 | | | | `--RPAREN -> ) [2013:79]
23590 | | | |--COMMA -> , [2013:80]
23591 | | | `--EXPR -> EXPR [2013:82]
23592 | | | `--IDENT -> expected [2013:82]
23593 | | `--RPAREN -> ) [2013:90]
23594 | |--SEMI -> ; [2013:91]
23595 | `--RCURLY -> } [2014:4]
23596 |--METHOD_DEF -> METHOD_DEF [2016:4]
23597 | |--MODIFIERS -> MODIFIERS [2016:4]
23598 | | |--ANNOTATION -> ANNOTATION [2016:4]
23599 | | | |--AT -> @ [2016:4]
23600 | | | `--IDENT -> Test [2016:5]
23601 | | `--LITERAL_PUBLIC -> public [2017:4]
23602 | |--TYPE -> TYPE [2017:11]
23603 | | `--LITERAL_VOID -> void [2017:11]
23604 | |--IDENT -> testInvalidAssignWithChecker [2017:16]
23605 | |--LPAREN -> ( [2017:44]
23606 | |--PARAMETERS -> PARAMETERS [2017:45]
23607 | |--RPAREN -> ) [2017:45]
23608 | |--LITERAL_THROWS -> throws [2017:47]
23609 | | `--IDENT -> Exception [2017:54]
23610 | `--SLIST -> { [2017:64]
23611 | |--VARIABLE_DEF -> VARIABLE_DEF [2018:8]
23612 | | |--MODIFIERS -> MODIFIERS [2018:8]
23613 | | | `--FINAL -> final [2018:8]
23614 | | |--TYPE -> TYPE [2018:14]
23615 | | | `--IDENT -> DefaultConfiguration [2018:14]
23616 | | |--IDENT -> checkConfig [2018:35]
23617 | | `--ASSIGN -> = [2018:47]
23618 | | `--EXPR -> EXPR [2018:67]
23619 | | `--METHOD_CALL -> ( [2018:67]
23620 | | |--IDENT -> createModuleConfig [2018:49]
23621 | | |--ELIST -> ELIST [2018:84]
23622 | | | `--EXPR -> EXPR [2018:84]
23623 | | | `--DOT -> . [2018:84]
23624 | | | |--IDENT -> IndentationCheck [2018:68]
23625 | | | `--LITERAL_CLASS -> class [2018:85]
23626 | | `--RPAREN -> ) [2018:90]
23627 | |--SEMI -> ; [2018:91]
23628 | |--EXPR -> EXPR [2020:32]
23629 | | `--METHOD_CALL -> ( [2020:32]
23630 | | |--DOT -> . [2020:19]
23631 | | | |--IDENT -> checkConfig [2020:8]
23632 | | | `--IDENT -> addAttribute [2020:20]
23633 | | |--ELIST -> ELIST [2020:33]
23634 | | | |--EXPR -> EXPR [2020:33]
23635 | | | | `--STRING_LITERAL -> "arrayInitIndent" [2020:33]
23636 | | | |--COMMA -> , [2020:50]
23637 | | | `--EXPR -> EXPR [2020:52]
23638 | | | `--STRING_LITERAL -> "4" [2020:52]
23639 | | `--RPAREN -> ) [2020:55]
23640 | |--SEMI -> ; [2020:56]
23641 | |--EXPR -> EXPR [2021:32]
23642 | | `--METHOD_CALL -> ( [2021:32]
23643 | | |--DOT -> . [2021:19]
23644 | | | |--IDENT -> checkConfig [2021:8]
23645 | | | `--IDENT -> addAttribute [2021:20]
23646 | | |--ELIST -> ELIST [2021:33]
23647 | | | |--EXPR -> EXPR [2021:33]
23648 | | | | `--STRING_LITERAL -> "basicOffset" [2021:33]
23649 | | | |--COMMA -> , [2021:46]
23650 | | | `--EXPR -> EXPR [2021:48]
23651 | | | `--STRING_LITERAL -> "4" [2021:48]
23652 | | `--RPAREN -> ) [2021:51]
23653 | |--SEMI -> ; [2021:52]
23654 | |--EXPR -> EXPR [2022:32]
23655 | | `--METHOD_CALL -> ( [2022:32]
23656 | | |--DOT -> . [2022:19]
23657 | | | |--IDENT -> checkConfig [2022:8]
23658 | | | `--IDENT -> addAttribute [2022:20]
23659 | | |--ELIST -> ELIST [2022:33]
23660 | | | |--EXPR -> EXPR [2022:33]
23661 | | | | `--STRING_LITERAL -> "braceAdjustment" [2022:33]
23662 | | | |--COMMA -> , [2022:50]
23663 | | | `--EXPR -> EXPR [2022:52]
23664 | | | `--STRING_LITERAL -> "0" [2022:52]
23665 | | `--RPAREN -> ) [2022:55]
23666 | |--SEMI -> ; [2022:56]
23667 | |--EXPR -> EXPR [2023:32]
23668 | | `--METHOD_CALL -> ( [2023:32]
23669 | | |--DOT -> . [2023:19]
23670 | | | |--IDENT -> checkConfig [2023:8]
23671 | | | `--IDENT -> addAttribute [2023:20]
23672 | | |--ELIST -> ELIST [2023:33]
23673 | | | |--EXPR -> EXPR [2023:33]
23674 | | | | `--STRING_LITERAL -> "caseIndent" [2023:33]
23675 | | | |--COMMA -> , [2023:45]
23676 | | | `--EXPR -> EXPR [2023:47]
23677 | | | `--STRING_LITERAL -> "4" [2023:47]
23678 | | `--RPAREN -> ) [2023:50]
23679 | |--SEMI -> ; [2023:51]
23680 | |--EXPR -> EXPR [2024:32]
23681 | | `--METHOD_CALL -> ( [2024:32]
23682 | | |--DOT -> . [2024:19]
23683 | | | |--IDENT -> checkConfig [2024:8]
23684 | | | `--IDENT -> addAttribute [2024:20]
23685 | | |--ELIST -> ELIST [2024:33]
23686 | | | |--EXPR -> EXPR [2024:33]
23687 | | | | `--STRING_LITERAL -> "forceStrictCondition" [2024:33]
23688 | | | |--COMMA -> , [2024:55]
23689 | | | `--EXPR -> EXPR [2024:57]
23690 | | | `--STRING_LITERAL -> "false" [2024:57]
23691 | | `--RPAREN -> ) [2024:64]
23692 | |--SEMI -> ; [2024:65]
23693 | |--EXPR -> EXPR [2025:32]
23694 | | `--METHOD_CALL -> ( [2025:32]
23695 | | |--DOT -> . [2025:19]
23696 | | | |--IDENT -> checkConfig [2025:8]
23697 | | | `--IDENT -> addAttribute [2025:20]
23698 | | |--ELIST -> ELIST [2025:33]
23699 | | | |--EXPR -> EXPR [2025:33]
23700 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2025:33]
23701 | | | |--COMMA -> , [2025:58]
23702 | | | `--EXPR -> EXPR [2025:60]
23703 | | | `--STRING_LITERAL -> "4" [2025:60]
23704 | | `--RPAREN -> ) [2025:63]
23705 | |--SEMI -> ; [2025:64]
23706 | |--EXPR -> EXPR [2026:32]
23707 | | `--METHOD_CALL -> ( [2026:32]
23708 | | |--DOT -> . [2026:19]
23709 | | | |--IDENT -> checkConfig [2026:8]
23710 | | | `--IDENT -> addAttribute [2026:20]
23711 | | |--ELIST -> ELIST [2026:33]
23712 | | | |--EXPR -> EXPR [2026:33]
23713 | | | | `--STRING_LITERAL -> "tabWidth" [2026:33]
23714 | | | |--COMMA -> , [2026:43]
23715 | | | `--EXPR -> EXPR [2026:45]
23716 | | | `--STRING_LITERAL -> "4" [2026:45]
23717 | | `--RPAREN -> ) [2026:48]
23718 | |--SEMI -> ; [2026:49]
23719 | |--EXPR -> EXPR [2027:32]
23720 | | `--METHOD_CALL -> ( [2027:32]
23721 | | |--DOT -> . [2027:19]
23722 | | | |--IDENT -> checkConfig [2027:8]
23723 | | | `--IDENT -> addAttribute [2027:20]
23724 | | |--ELIST -> ELIST [2027:33]
23725 | | | |--EXPR -> EXPR [2027:33]
23726 | | | | `--STRING_LITERAL -> "throwsIndent" [2027:33]
23727 | | | |--COMMA -> , [2027:47]
23728 | | | `--EXPR -> EXPR [2027:49]
23729 | | | `--STRING_LITERAL -> "4" [2027:49]
23730 | | `--RPAREN -> ) [2027:52]
23731 | |--SEMI -> ; [2027:53]
23732 | |--VARIABLE_DEF -> VARIABLE_DEF [2028:8]
23733 | | |--MODIFIERS -> MODIFIERS [2028:8]
23734 | | | `--FINAL -> final [2028:8]
23735 | | |--TYPE -> TYPE [2028:20]
23736 | | | `--ARRAY_DECLARATOR -> [ [2028:20]
23737 | | | |--IDENT -> String [2028:14]
23738 | | | `--RBRACK -> ] [2028:21]
23739 | | |--IDENT -> expected [2028:23]
23740 | | `--ASSIGN -> = [2028:32]
23741 | | `--ARRAY_INIT -> { [2028:34]
23742 | | |--EXPR -> EXPR [2029:22]
23743 | | | `--PLUS -> + [2029:22]
23744 | | | |--STRING_LITERAL -> "22:11: " [2029:12]
23745 | | | `--METHOD_CALL -> ( [2029:39]
23746 | | | |--IDENT -> getCheckMessage [2029:24]
23747 | | | |--ELIST -> ELIST [2029:40]
23748 | | | | |--EXPR -> EXPR [2029:40]
23749 | | | | | `--IDENT -> MSG_ERROR [2029:40]
23750 | | | | |--COMMA -> , [2029:49]
23751 | | | | |--EXPR -> EXPR [2029:51]
23752 | | | | | `--STRING_LITERAL -> "getLineNo" [2029:51]
23753 | | | | |--COMMA -> , [2029:62]
23754 | | | | |--EXPR -> EXPR [2029:64]
23755 | | | | | `--NUM_INT -> 10 [2029:64]
23756 | | | | |--COMMA -> , [2029:66]
23757 | | | | `--EXPR -> EXPR [2029:68]
23758 | | | | `--NUM_INT -> 12 [2029:68]
23759 | | | `--RPAREN -> ) [2029:70]
23760 | | |--COMMA -> , [2029:71]
23761 | | |--EXPR -> EXPR [2030:22]
23762 | | | `--PLUS -> + [2030:22]
23763 | | | |--STRING_LITERAL -> "24:11: " [2030:12]
23764 | | | `--METHOD_CALL -> ( [2030:39]
23765 | | | |--IDENT -> getCheckMessage [2030:24]
23766 | | | |--ELIST -> ELIST [2030:40]
23767 | | | | |--EXPR -> EXPR [2030:40]
23768 | | | | | `--IDENT -> MSG_ERROR [2030:40]
23769 | | | | |--COMMA -> , [2030:49]
23770 | | | | |--EXPR -> EXPR [2030:51]
23771 | | | | | `--STRING_LITERAL -> "getLine" [2030:51]
23772 | | | | |--COMMA -> , [2030:60]
23773 | | | | |--EXPR -> EXPR [2030:62]
23774 | | | | | `--NUM_INT -> 10 [2030:62]
23775 | | | | |--COMMA -> , [2030:64]
23776 | | | | `--EXPR -> EXPR [2030:66]
23777 | | | | `--NUM_INT -> 12 [2030:66]
23778 | | | `--RPAREN -> ) [2030:68]
23779 | | |--COMMA -> , [2030:69]
23780 | | |--EXPR -> EXPR [2031:22]
23781 | | | `--PLUS -> + [2031:22]
23782 | | | |--STRING_LITERAL -> "28:10: " [2031:12]
23783 | | | `--METHOD_CALL -> ( [2031:39]
23784 | | | |--IDENT -> getCheckMessage [2031:24]
23785 | | | |--ELIST -> ELIST [2031:40]
23786 | | | | |--EXPR -> EXPR [2031:40]
23787 | | | | | `--IDENT -> MSG_ERROR [2031:40]
23788 | | | | |--COMMA -> , [2031:49]
23789 | | | | |--EXPR -> EXPR [2031:51]
23790 | | | | | `--STRING_LITERAL -> "=" [2031:51]
23791 | | | | |--COMMA -> , [2031:54]
23792 | | | | |--EXPR -> EXPR [2031:56]
23793 | | | | | `--NUM_INT -> 9 [2031:56]
23794 | | | | |--COMMA -> , [2031:57]
23795 | | | | `--EXPR -> EXPR [2031:59]
23796 | | | | `--NUM_INT -> 12 [2031:59]
23797 | | | `--RPAREN -> ) [2031:61]
23798 | | |--COMMA -> , [2031:62]
23799 | | |--EXPR -> EXPR [2032:22]
23800 | | | `--PLUS -> + [2032:22]
23801 | | | |--STRING_LITERAL -> "29:11: " [2032:12]
23802 | | | `--METHOD_CALL -> ( [2032:39]
23803 | | | |--IDENT -> getCheckMessage [2032:24]
23804 | | | |--ELIST -> ELIST [2032:40]
23805 | | | | |--EXPR -> EXPR [2032:40]
23806 | | | | | `--IDENT -> MSG_ERROR [2032:40]
23807 | | | | |--COMMA -> , [2032:49]
23808 | | | | |--EXPR -> EXPR [2032:51]
23809 | | | | | `--STRING_LITERAL -> "1" [2032:51]
23810 | | | | |--COMMA -> , [2032:54]
23811 | | | | |--EXPR -> EXPR [2032:56]
23812 | | | | | `--NUM_INT -> 10 [2032:56]
23813 | | | | |--COMMA -> , [2032:58]
23814 | | | | `--EXPR -> EXPR [2032:60]
23815 | | | | `--NUM_INT -> 12 [2032:60]
23816 | | | `--RPAREN -> ) [2032:62]
23817 | | |--COMMA -> , [2032:63]
23818 | | `--RCURLY -> } [2033:8]
23819 | |--SEMI -> ; [2033:9]
23820 | |--EXPR -> EXPR [2034:19]
23821 | | `--METHOD_CALL -> ( [2034:19]
23822 | | |--IDENT -> verifyWarns [2034:8]
23823 | | |--ELIST -> ELIST [2034:20]
23824 | | | |--EXPR -> EXPR [2034:20]
23825 | | | | `--IDENT -> checkConfig [2034:20]
23826 | | | |--COMMA -> , [2034:31]
23827 | | | |--EXPR -> EXPR [2034:40]
23828 | | | | `--METHOD_CALL -> ( [2034:40]
23829 | | | | |--IDENT -> getPath [2034:33]
23830 | | | | |--ELIST -> ELIST [2034:41]
23831 | | | | | `--EXPR -> EXPR [2034:41]
23832 | | | | | `--STRING_LITERAL -> "InputIndentationInvalidAssignIndent.java" [2034:41]
23833 | | | | `--RPAREN -> ) [2034:83]
23834 | | | |--COMMA -> , [2034:84]
23835 | | | `--EXPR -> EXPR [2034:86]
23836 | | | `--IDENT -> expected [2034:86]
23837 | | `--RPAREN -> ) [2034:94]
23838 | |--SEMI -> ; [2034:95]
23839 | `--RCURLY -> } [2035:4]
23840 |--METHOD_DEF -> METHOD_DEF [2037:4]
23841 | |--MODIFIERS -> MODIFIERS [2037:4]
23842 | | |--ANNOTATION -> ANNOTATION [2037:4]
23843 | | | |--AT -> @ [2037:4]
23844 | | | `--IDENT -> Test [2037:5]
23845 | | `--LITERAL_PUBLIC -> public [2038:4]
23846 | |--TYPE -> TYPE [2038:11]
23847 | | `--LITERAL_VOID -> void [2038:11]
23848 | |--IDENT -> testInvalidImportIndent [2038:16]
23849 | |--LPAREN -> ( [2038:39]
23850 | |--PARAMETERS -> PARAMETERS [2038:40]
23851 | |--RPAREN -> ) [2038:40]
23852 | |--LITERAL_THROWS -> throws [2038:42]
23853 | | `--IDENT -> Exception [2038:49]
23854 | `--SLIST -> { [2038:59]
23855 | |--VARIABLE_DEF -> VARIABLE_DEF [2039:8]
23856 | | |--MODIFIERS -> MODIFIERS [2039:8]
23857 | | | `--FINAL -> final [2039:8]
23858 | | |--TYPE -> TYPE [2039:14]
23859 | | | `--IDENT -> DefaultConfiguration [2039:14]
23860 | | |--IDENT -> checkConfig [2039:35]
23861 | | `--ASSIGN -> = [2039:47]
23862 | | `--EXPR -> EXPR [2039:67]
23863 | | `--METHOD_CALL -> ( [2039:67]
23864 | | |--IDENT -> createModuleConfig [2039:49]
23865 | | |--ELIST -> ELIST [2039:84]
23866 | | | `--EXPR -> EXPR [2039:84]
23867 | | | `--DOT -> . [2039:84]
23868 | | | |--IDENT -> IndentationCheck [2039:68]
23869 | | | `--LITERAL_CLASS -> class [2039:85]
23870 | | `--RPAREN -> ) [2039:90]
23871 | |--SEMI -> ; [2039:91]
23872 | |--EXPR -> EXPR [2040:32]
23873 | | `--METHOD_CALL -> ( [2040:32]
23874 | | |--DOT -> . [2040:19]
23875 | | | |--IDENT -> checkConfig [2040:8]
23876 | | | `--IDENT -> addAttribute [2040:20]
23877 | | |--ELIST -> ELIST [2040:33]
23878 | | | |--EXPR -> EXPR [2040:33]
23879 | | | | `--STRING_LITERAL -> "basicOffset" [2040:33]
23880 | | | |--COMMA -> , [2040:46]
23881 | | | `--EXPR -> EXPR [2040:48]
23882 | | | `--STRING_LITERAL -> "8" [2040:48]
23883 | | `--RPAREN -> ) [2040:51]
23884 | |--SEMI -> ; [2040:52]
23885 | |--EXPR -> EXPR [2041:32]
23886 | | `--METHOD_CALL -> ( [2041:32]
23887 | | |--DOT -> . [2041:19]
23888 | | | |--IDENT -> checkConfig [2041:8]
23889 | | | `--IDENT -> addAttribute [2041:20]
23890 | | |--ELIST -> ELIST [2041:33]
23891 | | | |--EXPR -> EXPR [2041:33]
23892 | | | | `--STRING_LITERAL -> "tabWidth" [2041:33]
23893 | | | |--COMMA -> , [2041:43]
23894 | | | `--EXPR -> EXPR [2041:45]
23895 | | | `--STRING_LITERAL -> "4" [2041:45]
23896 | | `--RPAREN -> ) [2041:48]
23897 | |--SEMI -> ; [2041:49]
23898 | |--VARIABLE_DEF -> VARIABLE_DEF [2042:8]
23899 | | |--MODIFIERS -> MODIFIERS [2042:8]
23900 | | | `--FINAL -> final [2042:8]
23901 | | |--TYPE -> TYPE [2042:20]
23902 | | | `--ARRAY_DECLARATOR -> [ [2042:20]
23903 | | | |--IDENT -> String [2042:14]
23904 | | | `--RBRACK -> ] [2042:21]
23905 | | |--IDENT -> expected [2042:23]
23906 | | `--ASSIGN -> = [2042:32]
23907 | | `--ARRAY_INIT -> { [2042:34]
23908 | | |--EXPR -> EXPR [2043:20]
23909 | | | `--PLUS -> + [2043:20]
23910 | | | |--STRING_LITERAL -> "4:3: " [2043:12]
23911 | | | `--METHOD_CALL -> ( [2043:37]
23912 | | | |--IDENT -> getCheckMessage [2043:22]
23913 | | | |--ELIST -> ELIST [2043:38]
23914 | | | | |--EXPR -> EXPR [2043:38]
23915 | | | | | `--IDENT -> MSG_ERROR [2043:38]
23916 | | | | |--COMMA -> , [2043:47]
23917 | | | | |--EXPR -> EXPR [2043:49]
23918 | | | | | `--STRING_LITERAL -> "." [2043:49]
23919 | | | | |--COMMA -> , [2043:52]
23920 | | | | |--EXPR -> EXPR [2043:54]
23921 | | | | | `--NUM_INT -> 2 [2043:54]
23922 | | | | |--COMMA -> , [2043:55]
23923 | | | | `--EXPR -> EXPR [2043:57]
23924 | | | | `--NUM_INT -> 4 [2043:57]
23925 | | | `--RPAREN -> ) [2043:58]
23926 | | |--COMMA -> , [2043:59]
23927 | | |--EXPR -> EXPR [2044:20]
23928 | | | `--PLUS -> + [2044:20]
23929 | | | |--STRING_LITERAL -> "5:2: " [2044:12]
23930 | | | `--METHOD_CALL -> ( [2044:37]
23931 | | | |--IDENT -> getCheckMessage [2044:22]
23932 | | | |--ELIST -> ELIST [2044:38]
23933 | | | | |--EXPR -> EXPR [2044:38]
23934 | | | | | `--IDENT -> MSG_ERROR [2044:38]
23935 | | | | |--COMMA -> , [2044:47]
23936 | | | | |--EXPR -> EXPR [2044:49]
23937 | | | | | `--STRING_LITERAL -> "import" [2044:49]
23938 | | | | |--COMMA -> , [2044:57]
23939 | | | | |--EXPR -> EXPR [2044:59]
23940 | | | | | `--NUM_INT -> 1 [2044:59]
23941 | | | | |--COMMA -> , [2044:60]
23942 | | | | `--EXPR -> EXPR [2044:62]
23943 | | | | `--NUM_INT -> 0 [2044:62]
23944 | | | `--RPAREN -> ) [2044:63]
23945 | | |--COMMA -> , [2044:64]
23946 | | `--RCURLY -> } [2045:8]
23947 | |--SEMI -> ; [2045:9]
23948 | |--EXPR -> EXPR [2046:19]
23949 | | `--METHOD_CALL -> ( [2046:19]
23950 | | |--IDENT -> verifyWarns [2046:8]
23951 | | |--ELIST -> ELIST [2046:20]
23952 | | | |--EXPR -> EXPR [2046:20]
23953 | | | | `--IDENT -> checkConfig [2046:20]
23954 | | | |--COMMA -> , [2046:31]
23955 | | | |--EXPR -> EXPR [2046:40]
23956 | | | | `--METHOD_CALL -> ( [2046:40]
23957 | | | | |--IDENT -> getPath [2046:33]
23958 | | | | |--ELIST -> ELIST [2046:41]
23959 | | | | | `--EXPR -> EXPR [2046:41]
23960 | | | | | `--STRING_LITERAL -> "InputIndentationInvalidImportIndent.java" [2046:41]
23961 | | | | `--RPAREN -> ) [2046:83]
23962 | | | |--COMMA -> , [2046:84]
23963 | | | `--EXPR -> EXPR [2046:86]
23964 | | | `--IDENT -> expected [2046:86]
23965 | | `--RPAREN -> ) [2046:94]
23966 | |--SEMI -> ; [2046:95]
23967 | `--RCURLY -> } [2047:4]
23968 |--METHOD_DEF -> METHOD_DEF [2049:4]
23969 | |--MODIFIERS -> MODIFIERS [2049:4]
23970 | | |--ANNOTATION -> ANNOTATION [2049:4]
23971 | | | |--AT -> @ [2049:4]
23972 | | | `--IDENT -> Test [2049:5]
23973 | | `--LITERAL_PUBLIC -> public [2050:4]
23974 | |--TYPE -> TYPE [2050:11]
23975 | | `--LITERAL_VOID -> void [2050:11]
23976 | |--IDENT -> testValidAssignWithChecker [2050:16]
23977 | |--LPAREN -> ( [2050:42]
23978 | |--PARAMETERS -> PARAMETERS [2050:43]
23979 | |--RPAREN -> ) [2050:43]
23980 | |--LITERAL_THROWS -> throws [2050:45]
23981 | | `--IDENT -> Exception [2050:52]
23982 | `--SLIST -> { [2050:62]
23983 | |--VARIABLE_DEF -> VARIABLE_DEF [2051:8]
23984 | | |--MODIFIERS -> MODIFIERS [2051:8]
23985 | | | `--FINAL -> final [2051:8]
23986 | | |--TYPE -> TYPE [2051:14]
23987 | | | `--IDENT -> DefaultConfiguration [2051:14]
23988 | | |--IDENT -> checkConfig [2051:35]
23989 | | `--ASSIGN -> = [2051:47]
23990 | | `--EXPR -> EXPR [2051:67]
23991 | | `--METHOD_CALL -> ( [2051:67]
23992 | | |--IDENT -> createModuleConfig [2051:49]
23993 | | |--ELIST -> ELIST [2051:84]
23994 | | | `--EXPR -> EXPR [2051:84]
23995 | | | `--DOT -> . [2051:84]
23996 | | | |--IDENT -> IndentationCheck [2051:68]
23997 | | | `--LITERAL_CLASS -> class [2051:85]
23998 | | `--RPAREN -> ) [2051:90]
23999 | |--SEMI -> ; [2051:91]
24000 | |--EXPR -> EXPR [2053:32]
24001 | | `--METHOD_CALL -> ( [2053:32]
24002 | | |--DOT -> . [2053:19]
24003 | | | |--IDENT -> checkConfig [2053:8]
24004 | | | `--IDENT -> addAttribute [2053:20]
24005 | | |--ELIST -> ELIST [2053:33]
24006 | | | |--EXPR -> EXPR [2053:33]
24007 | | | | `--STRING_LITERAL -> "arrayInitIndent" [2053:33]
24008 | | | |--COMMA -> , [2053:50]
24009 | | | `--EXPR -> EXPR [2053:52]
24010 | | | `--STRING_LITERAL -> "4" [2053:52]
24011 | | `--RPAREN -> ) [2053:55]
24012 | |--SEMI -> ; [2053:56]
24013 | |--EXPR -> EXPR [2054:32]
24014 | | `--METHOD_CALL -> ( [2054:32]
24015 | | |--DOT -> . [2054:19]
24016 | | | |--IDENT -> checkConfig [2054:8]
24017 | | | `--IDENT -> addAttribute [2054:20]
24018 | | |--ELIST -> ELIST [2054:33]
24019 | | | |--EXPR -> EXPR [2054:33]
24020 | | | | `--STRING_LITERAL -> "basicOffset" [2054:33]
24021 | | | |--COMMA -> , [2054:46]
24022 | | | `--EXPR -> EXPR [2054:48]
24023 | | | `--STRING_LITERAL -> "4" [2054:48]
24024 | | `--RPAREN -> ) [2054:51]
24025 | |--SEMI -> ; [2054:52]
24026 | |--EXPR -> EXPR [2055:32]
24027 | | `--METHOD_CALL -> ( [2055:32]
24028 | | |--DOT -> . [2055:19]
24029 | | | |--IDENT -> checkConfig [2055:8]
24030 | | | `--IDENT -> addAttribute [2055:20]
24031 | | |--ELIST -> ELIST [2055:33]
24032 | | | |--EXPR -> EXPR [2055:33]
24033 | | | | `--STRING_LITERAL -> "braceAdjustment" [2055:33]
24034 | | | |--COMMA -> , [2055:50]
24035 | | | `--EXPR -> EXPR [2055:52]
24036 | | | `--STRING_LITERAL -> "0" [2055:52]
24037 | | `--RPAREN -> ) [2055:55]
24038 | |--SEMI -> ; [2055:56]
24039 | |--EXPR -> EXPR [2056:32]
24040 | | `--METHOD_CALL -> ( [2056:32]
24041 | | |--DOT -> . [2056:19]
24042 | | | |--IDENT -> checkConfig [2056:8]
24043 | | | `--IDENT -> addAttribute [2056:20]
24044 | | |--ELIST -> ELIST [2056:33]
24045 | | | |--EXPR -> EXPR [2056:33]
24046 | | | | `--STRING_LITERAL -> "caseIndent" [2056:33]
24047 | | | |--COMMA -> , [2056:45]
24048 | | | `--EXPR -> EXPR [2056:47]
24049 | | | `--STRING_LITERAL -> "4" [2056:47]
24050 | | `--RPAREN -> ) [2056:50]
24051 | |--SEMI -> ; [2056:51]
24052 | |--EXPR -> EXPR [2057:32]
24053 | | `--METHOD_CALL -> ( [2057:32]
24054 | | |--DOT -> . [2057:19]
24055 | | | |--IDENT -> checkConfig [2057:8]
24056 | | | `--IDENT -> addAttribute [2057:20]
24057 | | |--ELIST -> ELIST [2057:33]
24058 | | | |--EXPR -> EXPR [2057:33]
24059 | | | | `--STRING_LITERAL -> "forceStrictCondition" [2057:33]
24060 | | | |--COMMA -> , [2057:55]
24061 | | | `--EXPR -> EXPR [2057:57]
24062 | | | `--STRING_LITERAL -> "false" [2057:57]
24063 | | `--RPAREN -> ) [2057:64]
24064 | |--SEMI -> ; [2057:65]
24065 | |--EXPR -> EXPR [2058:32]
24066 | | `--METHOD_CALL -> ( [2058:32]
24067 | | |--DOT -> . [2058:19]
24068 | | | |--IDENT -> checkConfig [2058:8]
24069 | | | `--IDENT -> addAttribute [2058:20]
24070 | | |--ELIST -> ELIST [2058:33]
24071 | | | |--EXPR -> EXPR [2058:33]
24072 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2058:33]
24073 | | | |--COMMA -> , [2058:58]
24074 | | | `--EXPR -> EXPR [2058:60]
24075 | | | `--STRING_LITERAL -> "4" [2058:60]
24076 | | `--RPAREN -> ) [2058:63]
24077 | |--SEMI -> ; [2058:64]
24078 | |--EXPR -> EXPR [2059:32]
24079 | | `--METHOD_CALL -> ( [2059:32]
24080 | | |--DOT -> . [2059:19]
24081 | | | |--IDENT -> checkConfig [2059:8]
24082 | | | `--IDENT -> addAttribute [2059:20]
24083 | | |--ELIST -> ELIST [2059:33]
24084 | | | |--EXPR -> EXPR [2059:33]
24085 | | | | `--STRING_LITERAL -> "tabWidth" [2059:33]
24086 | | | |--COMMA -> , [2059:43]
24087 | | | `--EXPR -> EXPR [2059:45]
24088 | | | `--STRING_LITERAL -> "4" [2059:45]
24089 | | `--RPAREN -> ) [2059:48]
24090 | |--SEMI -> ; [2059:49]
24091 | |--EXPR -> EXPR [2060:32]
24092 | | `--METHOD_CALL -> ( [2060:32]
24093 | | |--DOT -> . [2060:19]
24094 | | | |--IDENT -> checkConfig [2060:8]
24095 | | | `--IDENT -> addAttribute [2060:20]
24096 | | |--ELIST -> ELIST [2060:33]
24097 | | | |--EXPR -> EXPR [2060:33]
24098 | | | | `--STRING_LITERAL -> "throwsIndent" [2060:33]
24099 | | | |--COMMA -> , [2060:47]
24100 | | | `--EXPR -> EXPR [2060:49]
24101 | | | `--STRING_LITERAL -> "4" [2060:49]
24102 | | `--RPAREN -> ) [2060:52]
24103 | |--SEMI -> ; [2060:53]
24104 | |--VARIABLE_DEF -> VARIABLE_DEF [2061:8]
24105 | | |--MODIFIERS -> MODIFIERS [2061:8]
24106 | | | `--FINAL -> final [2061:8]
24107 | | |--TYPE -> TYPE [2061:20]
24108 | | | `--ARRAY_DECLARATOR -> [ [2061:20]
24109 | | | |--IDENT -> String [2061:14]
24110 | | | `--RBRACK -> ] [2061:21]
24111 | | |--IDENT -> expected [2061:23]
24112 | | `--ASSIGN -> = [2061:32]
24113 | | `--EXPR -> EXPR [2061:44]
24114 | | `--DOT -> . [2061:44]
24115 | | |--IDENT -> CommonUtil [2061:34]
24116 | | `--IDENT -> EMPTY_STRING_ARRAY [2061:45]
24117 | |--SEMI -> ; [2061:63]
24118 | |--EXPR -> EXPR [2062:19]
24119 | | `--METHOD_CALL -> ( [2062:19]
24120 | | |--IDENT -> verifyWarns [2062:8]
24121 | | |--ELIST -> ELIST [2062:20]
24122 | | | |--EXPR -> EXPR [2062:20]
24123 | | | | `--IDENT -> checkConfig [2062:20]
24124 | | | |--COMMA -> , [2062:31]
24125 | | | |--EXPR -> EXPR [2062:40]
24126 | | | | `--METHOD_CALL -> ( [2062:40]
24127 | | | | |--IDENT -> getPath [2062:33]
24128 | | | | |--ELIST -> ELIST [2062:41]
24129 | | | | | `--EXPR -> EXPR [2062:41]
24130 | | | | | `--STRING_LITERAL -> "InputIndentationValidAssignIndent.java" [2062:41]
24131 | | | | `--RPAREN -> ) [2062:81]
24132 | | | |--COMMA -> , [2062:82]
24133 | | | `--EXPR -> EXPR [2062:84]
24134 | | | `--IDENT -> expected [2062:84]
24135 | | `--RPAREN -> ) [2062:92]
24136 | |--SEMI -> ; [2062:93]
24137 | `--RCURLY -> } [2063:4]
24138 |--METHOD_DEF -> METHOD_DEF [2065:4]
24139 | |--MODIFIERS -> MODIFIERS [2065:4]
24140 | | |--ANNOTATION -> ANNOTATION [2065:4]
24141 | | | |--AT -> @ [2065:4]
24142 | | | `--IDENT -> Test [2065:5]
24143 | | `--LITERAL_PUBLIC -> public [2066:4]
24144 | |--TYPE -> TYPE [2066:11]
24145 | | `--LITERAL_VOID -> void [2066:11]
24146 | |--IDENT -> test15Extensions [2066:16]
24147 | |--LPAREN -> ( [2066:32]
24148 | |--PARAMETERS -> PARAMETERS [2066:33]
24149 | |--RPAREN -> ) [2066:33]
24150 | |--LITERAL_THROWS -> throws [2066:35]
24151 | | `--IDENT -> Exception [2066:42]
24152 | `--SLIST -> { [2066:52]
24153 | |--VARIABLE_DEF -> VARIABLE_DEF [2067:8]
24154 | | |--MODIFIERS -> MODIFIERS [2067:8]
24155 | | | `--FINAL -> final [2067:8]
24156 | | |--TYPE -> TYPE [2067:14]
24157 | | | `--IDENT -> DefaultConfiguration [2067:14]
24158 | | |--IDENT -> checkConfig [2067:35]
24159 | | `--ASSIGN -> = [2067:47]
24160 | | `--EXPR -> EXPR [2067:67]
24161 | | `--METHOD_CALL -> ( [2067:67]
24162 | | |--IDENT -> createModuleConfig [2067:49]
24163 | | |--ELIST -> ELIST [2067:84]
24164 | | | `--EXPR -> EXPR [2067:84]
24165 | | | `--DOT -> . [2067:84]
24166 | | | |--IDENT -> IndentationCheck [2067:68]
24167 | | | `--LITERAL_CLASS -> class [2067:85]
24168 | | `--RPAREN -> ) [2067:90]
24169 | |--SEMI -> ; [2067:91]
24170 | |--EXPR -> EXPR [2069:32]
24171 | | `--METHOD_CALL -> ( [2069:32]
24172 | | |--DOT -> . [2069:19]
24173 | | | |--IDENT -> checkConfig [2069:8]
24174 | | | `--IDENT -> addAttribute [2069:20]
24175 | | |--ELIST -> ELIST [2069:33]
24176 | | | |--EXPR -> EXPR [2069:33]
24177 | | | | `--STRING_LITERAL -> "arrayInitIndent" [2069:33]
24178 | | | |--COMMA -> , [2069:50]
24179 | | | `--EXPR -> EXPR [2069:52]
24180 | | | `--STRING_LITERAL -> "4" [2069:52]
24181 | | `--RPAREN -> ) [2069:55]
24182 | |--SEMI -> ; [2069:56]
24183 | |--EXPR -> EXPR [2070:32]
24184 | | `--METHOD_CALL -> ( [2070:32]
24185 | | |--DOT -> . [2070:19]
24186 | | | |--IDENT -> checkConfig [2070:8]
24187 | | | `--IDENT -> addAttribute [2070:20]
24188 | | |--ELIST -> ELIST [2070:33]
24189 | | | |--EXPR -> EXPR [2070:33]
24190 | | | | `--STRING_LITERAL -> "basicOffset" [2070:33]
24191 | | | |--COMMA -> , [2070:46]
24192 | | | `--EXPR -> EXPR [2070:48]
24193 | | | `--STRING_LITERAL -> "4" [2070:48]
24194 | | `--RPAREN -> ) [2070:51]
24195 | |--SEMI -> ; [2070:52]
24196 | |--EXPR -> EXPR [2071:32]
24197 | | `--METHOD_CALL -> ( [2071:32]
24198 | | |--DOT -> . [2071:19]
24199 | | | |--IDENT -> checkConfig [2071:8]
24200 | | | `--IDENT -> addAttribute [2071:20]
24201 | | |--ELIST -> ELIST [2071:33]
24202 | | | |--EXPR -> EXPR [2071:33]
24203 | | | | `--STRING_LITERAL -> "braceAdjustment" [2071:33]
24204 | | | |--COMMA -> , [2071:50]
24205 | | | `--EXPR -> EXPR [2071:52]
24206 | | | `--STRING_LITERAL -> "0" [2071:52]
24207 | | `--RPAREN -> ) [2071:55]
24208 | |--SEMI -> ; [2071:56]
24209 | |--EXPR -> EXPR [2072:32]
24210 | | `--METHOD_CALL -> ( [2072:32]
24211 | | |--DOT -> . [2072:19]
24212 | | | |--IDENT -> checkConfig [2072:8]
24213 | | | `--IDENT -> addAttribute [2072:20]
24214 | | |--ELIST -> ELIST [2072:33]
24215 | | | |--EXPR -> EXPR [2072:33]
24216 | | | | `--STRING_LITERAL -> "caseIndent" [2072:33]
24217 | | | |--COMMA -> , [2072:45]
24218 | | | `--EXPR -> EXPR [2072:47]
24219 | | | `--STRING_LITERAL -> "4" [2072:47]
24220 | | `--RPAREN -> ) [2072:50]
24221 | |--SEMI -> ; [2072:51]
24222 | |--EXPR -> EXPR [2073:32]
24223 | | `--METHOD_CALL -> ( [2073:32]
24224 | | |--DOT -> . [2073:19]
24225 | | | |--IDENT -> checkConfig [2073:8]
24226 | | | `--IDENT -> addAttribute [2073:20]
24227 | | |--ELIST -> ELIST [2073:33]
24228 | | | |--EXPR -> EXPR [2073:33]
24229 | | | | `--STRING_LITERAL -> "forceStrictCondition" [2073:33]
24230 | | | |--COMMA -> , [2073:55]
24231 | | | `--EXPR -> EXPR [2073:57]
24232 | | | `--STRING_LITERAL -> "false" [2073:57]
24233 | | `--RPAREN -> ) [2073:64]
24234 | |--SEMI -> ; [2073:65]
24235 | |--EXPR -> EXPR [2074:32]
24236 | | `--METHOD_CALL -> ( [2074:32]
24237 | | |--DOT -> . [2074:19]
24238 | | | |--IDENT -> checkConfig [2074:8]
24239 | | | `--IDENT -> addAttribute [2074:20]
24240 | | |--ELIST -> ELIST [2074:33]
24241 | | | |--EXPR -> EXPR [2074:33]
24242 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2074:33]
24243 | | | |--COMMA -> , [2074:58]
24244 | | | `--EXPR -> EXPR [2074:60]
24245 | | | `--STRING_LITERAL -> "4" [2074:60]
24246 | | `--RPAREN -> ) [2074:63]
24247 | |--SEMI -> ; [2074:64]
24248 | |--EXPR -> EXPR [2075:32]
24249 | | `--METHOD_CALL -> ( [2075:32]
24250 | | |--DOT -> . [2075:19]
24251 | | | |--IDENT -> checkConfig [2075:8]
24252 | | | `--IDENT -> addAttribute [2075:20]
24253 | | |--ELIST -> ELIST [2075:33]
24254 | | | |--EXPR -> EXPR [2075:33]
24255 | | | | `--STRING_LITERAL -> "tabWidth" [2075:33]
24256 | | | |--COMMA -> , [2075:43]
24257 | | | `--EXPR -> EXPR [2075:45]
24258 | | | `--STRING_LITERAL -> "4" [2075:45]
24259 | | `--RPAREN -> ) [2075:48]
24260 | |--SEMI -> ; [2075:49]
24261 | |--EXPR -> EXPR [2076:32]
24262 | | `--METHOD_CALL -> ( [2076:32]
24263 | | |--DOT -> . [2076:19]
24264 | | | |--IDENT -> checkConfig [2076:8]
24265 | | | `--IDENT -> addAttribute [2076:20]
24266 | | |--ELIST -> ELIST [2076:33]
24267 | | | |--EXPR -> EXPR [2076:33]
24268 | | | | `--STRING_LITERAL -> "throwsIndent" [2076:33]
24269 | | | |--COMMA -> , [2076:47]
24270 | | | `--EXPR -> EXPR [2076:49]
24271 | | | `--STRING_LITERAL -> "4" [2076:49]
24272 | | `--RPAREN -> ) [2076:52]
24273 | |--SEMI -> ; [2076:53]
24274 | |--VARIABLE_DEF -> VARIABLE_DEF [2077:8]
24275 | | |--MODIFIERS -> MODIFIERS [2077:8]
24276 | | | `--FINAL -> final [2077:8]
24277 | | |--TYPE -> TYPE [2077:20]
24278 | | | `--ARRAY_DECLARATOR -> [ [2077:20]
24279 | | | |--IDENT -> String [2077:14]
24280 | | | `--RBRACK -> ] [2077:21]
24281 | | |--IDENT -> expected [2077:23]
24282 | | `--ASSIGN -> = [2077:32]
24283 | | `--EXPR -> EXPR [2077:44]
24284 | | `--DOT -> . [2077:44]
24285 | | |--IDENT -> CommonUtil [2077:34]
24286 | | `--IDENT -> EMPTY_STRING_ARRAY [2077:45]
24287 | |--SEMI -> ; [2077:63]
24288 | |--EXPR -> EXPR [2078:19]
24289 | | `--METHOD_CALL -> ( [2078:19]
24290 | | |--IDENT -> verifyWarns [2078:8]
24291 | | |--ELIST -> ELIST [2078:20]
24292 | | | |--EXPR -> EXPR [2078:20]
24293 | | | | `--IDENT -> checkConfig [2078:20]
24294 | | | |--COMMA -> , [2078:31]
24295 | | | |--EXPR -> EXPR [2078:40]
24296 | | | | `--METHOD_CALL -> ( [2078:40]
24297 | | | | |--IDENT -> getPath [2078:33]
24298 | | | | |--ELIST -> ELIST [2078:41]
24299 | | | | | `--EXPR -> EXPR [2078:41]
24300 | | | | | `--STRING_LITERAL -> "InputIndentation15Extensions.java" [2078:41]
24301 | | | | `--RPAREN -> ) [2078:76]
24302 | | | |--COMMA -> , [2078:77]
24303 | | | `--EXPR -> EXPR [2078:79]
24304 | | | `--IDENT -> expected [2078:79]
24305 | | `--RPAREN -> ) [2078:87]
24306 | |--SEMI -> ; [2078:88]
24307 | `--RCURLY -> } [2079:4]
24308 |--METHOD_DEF -> METHOD_DEF [2081:4]
24309 | |--MODIFIERS -> MODIFIERS [2081:4]
24310 | | |--ANNOTATION -> ANNOTATION [2081:4]
24311 | | | |--AT -> @ [2081:4]
24312 | | | `--IDENT -> Test [2081:5]
24313 | | `--LITERAL_PUBLIC -> public [2082:4]
24314 | |--TYPE -> TYPE [2082:11]
24315 | | `--LITERAL_VOID -> void [2082:11]
24316 | |--IDENT -> testTryResources [2082:16]
24317 | |--LPAREN -> ( [2082:32]
24318 | |--PARAMETERS -> PARAMETERS [2082:33]
24319 | |--RPAREN -> ) [2082:33]
24320 | |--LITERAL_THROWS -> throws [2082:35]
24321 | | `--IDENT -> Exception [2082:42]
24322 | `--SLIST -> { [2082:52]
24323 | |--VARIABLE_DEF -> VARIABLE_DEF [2083:8]
24324 | | |--MODIFIERS -> MODIFIERS [2083:8]
24325 | | | `--FINAL -> final [2083:8]
24326 | | |--TYPE -> TYPE [2083:14]
24327 | | | `--IDENT -> DefaultConfiguration [2083:14]
24328 | | |--IDENT -> checkConfig [2083:35]
24329 | | `--ASSIGN -> = [2083:47]
24330 | | `--EXPR -> EXPR [2083:67]
24331 | | `--METHOD_CALL -> ( [2083:67]
24332 | | |--IDENT -> createModuleConfig [2083:49]
24333 | | |--ELIST -> ELIST [2083:84]
24334 | | | `--EXPR -> EXPR [2083:84]
24335 | | | `--DOT -> . [2083:84]
24336 | | | |--IDENT -> IndentationCheck [2083:68]
24337 | | | `--LITERAL_CLASS -> class [2083:85]
24338 | | `--RPAREN -> ) [2083:90]
24339 | |--SEMI -> ; [2083:91]
24340 | |--EXPR -> EXPR [2085:32]
24341 | | `--METHOD_CALL -> ( [2085:32]
24342 | | |--DOT -> . [2085:19]
24343 | | | |--IDENT -> checkConfig [2085:8]
24344 | | | `--IDENT -> addAttribute [2085:20]
24345 | | |--ELIST -> ELIST [2085:33]
24346 | | | |--EXPR -> EXPR [2085:33]
24347 | | | | `--STRING_LITERAL -> "arrayInitIndent" [2085:33]
24348 | | | |--COMMA -> , [2085:50]
24349 | | | `--EXPR -> EXPR [2085:52]
24350 | | | `--STRING_LITERAL -> "4" [2085:52]
24351 | | `--RPAREN -> ) [2085:55]
24352 | |--SEMI -> ; [2085:56]
24353 | |--EXPR -> EXPR [2086:32]
24354 | | `--METHOD_CALL -> ( [2086:32]
24355 | | |--DOT -> . [2086:19]
24356 | | | |--IDENT -> checkConfig [2086:8]
24357 | | | `--IDENT -> addAttribute [2086:20]
24358 | | |--ELIST -> ELIST [2086:33]
24359 | | | |--EXPR -> EXPR [2086:33]
24360 | | | | `--STRING_LITERAL -> "basicOffset" [2086:33]
24361 | | | |--COMMA -> , [2086:46]
24362 | | | `--EXPR -> EXPR [2086:48]
24363 | | | `--STRING_LITERAL -> "4" [2086:48]
24364 | | `--RPAREN -> ) [2086:51]
24365 | |--SEMI -> ; [2086:52]
24366 | |--EXPR -> EXPR [2087:32]
24367 | | `--METHOD_CALL -> ( [2087:32]
24368 | | |--DOT -> . [2087:19]
24369 | | | |--IDENT -> checkConfig [2087:8]
24370 | | | `--IDENT -> addAttribute [2087:20]
24371 | | |--ELIST -> ELIST [2087:33]
24372 | | | |--EXPR -> EXPR [2087:33]
24373 | | | | `--STRING_LITERAL -> "braceAdjustment" [2087:33]
24374 | | | |--COMMA -> , [2087:50]
24375 | | | `--EXPR -> EXPR [2087:52]
24376 | | | `--STRING_LITERAL -> "0" [2087:52]
24377 | | `--RPAREN -> ) [2087:55]
24378 | |--SEMI -> ; [2087:56]
24379 | |--EXPR -> EXPR [2088:32]
24380 | | `--METHOD_CALL -> ( [2088:32]
24381 | | |--DOT -> . [2088:19]
24382 | | | |--IDENT -> checkConfig [2088:8]
24383 | | | `--IDENT -> addAttribute [2088:20]
24384 | | |--ELIST -> ELIST [2088:33]
24385 | | | |--EXPR -> EXPR [2088:33]
24386 | | | | `--STRING_LITERAL -> "caseIndent" [2088:33]
24387 | | | |--COMMA -> , [2088:45]
24388 | | | `--EXPR -> EXPR [2088:47]
24389 | | | `--STRING_LITERAL -> "4" [2088:47]
24390 | | `--RPAREN -> ) [2088:50]
24391 | |--SEMI -> ; [2088:51]
24392 | |--EXPR -> EXPR [2089:32]
24393 | | `--METHOD_CALL -> ( [2089:32]
24394 | | |--DOT -> . [2089:19]
24395 | | | |--IDENT -> checkConfig [2089:8]
24396 | | | `--IDENT -> addAttribute [2089:20]
24397 | | |--ELIST -> ELIST [2089:33]
24398 | | | |--EXPR -> EXPR [2089:33]
24399 | | | | `--STRING_LITERAL -> "forceStrictCondition" [2089:33]
24400 | | | |--COMMA -> , [2089:55]
24401 | | | `--EXPR -> EXPR [2089:57]
24402 | | | `--STRING_LITERAL -> "false" [2089:57]
24403 | | `--RPAREN -> ) [2089:64]
24404 | |--SEMI -> ; [2089:65]
24405 | |--EXPR -> EXPR [2090:32]
24406 | | `--METHOD_CALL -> ( [2090:32]
24407 | | |--DOT -> . [2090:19]
24408 | | | |--IDENT -> checkConfig [2090:8]
24409 | | | `--IDENT -> addAttribute [2090:20]
24410 | | |--ELIST -> ELIST [2090:33]
24411 | | | |--EXPR -> EXPR [2090:33]
24412 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2090:33]
24413 | | | |--COMMA -> , [2090:58]
24414 | | | `--EXPR -> EXPR [2090:60]
24415 | | | `--STRING_LITERAL -> "4" [2090:60]
24416 | | `--RPAREN -> ) [2090:63]
24417 | |--SEMI -> ; [2090:64]
24418 | |--EXPR -> EXPR [2091:32]
24419 | | `--METHOD_CALL -> ( [2091:32]
24420 | | |--DOT -> . [2091:19]
24421 | | | |--IDENT -> checkConfig [2091:8]
24422 | | | `--IDENT -> addAttribute [2091:20]
24423 | | |--ELIST -> ELIST [2091:33]
24424 | | | |--EXPR -> EXPR [2091:33]
24425 | | | | `--STRING_LITERAL -> "tabWidth" [2091:33]
24426 | | | |--COMMA -> , [2091:43]
24427 | | | `--EXPR -> EXPR [2091:45]
24428 | | | `--STRING_LITERAL -> "4" [2091:45]
24429 | | `--RPAREN -> ) [2091:48]
24430 | |--SEMI -> ; [2091:49]
24431 | |--EXPR -> EXPR [2092:32]
24432 | | `--METHOD_CALL -> ( [2092:32]
24433 | | |--DOT -> . [2092:19]
24434 | | | |--IDENT -> checkConfig [2092:8]
24435 | | | `--IDENT -> addAttribute [2092:20]
24436 | | |--ELIST -> ELIST [2092:33]
24437 | | | |--EXPR -> EXPR [2092:33]
24438 | | | | `--STRING_LITERAL -> "throwsIndent" [2092:33]
24439 | | | |--COMMA -> , [2092:47]
24440 | | | `--EXPR -> EXPR [2092:49]
24441 | | | `--STRING_LITERAL -> "4" [2092:49]
24442 | | `--RPAREN -> ) [2092:52]
24443 | |--SEMI -> ; [2092:53]
24444 | |--VARIABLE_DEF -> VARIABLE_DEF [2093:8]
24445 | | |--MODIFIERS -> MODIFIERS [2093:8]
24446 | | | `--FINAL -> final [2093:8]
24447 | | |--TYPE -> TYPE [2093:20]
24448 | | | `--ARRAY_DECLARATOR -> [ [2093:20]
24449 | | | |--IDENT -> String [2093:14]
24450 | | | `--RBRACK -> ] [2093:21]
24451 | | |--IDENT -> expected [2093:23]
24452 | | `--ASSIGN -> = [2093:32]
24453 | | `--EXPR -> EXPR [2093:44]
24454 | | `--DOT -> . [2093:44]
24455 | | |--IDENT -> CommonUtil [2093:34]
24456 | | `--IDENT -> EMPTY_STRING_ARRAY [2093:45]
24457 | |--SEMI -> ; [2093:63]
24458 | |--EXPR -> EXPR [2094:19]
24459 | | `--METHOD_CALL -> ( [2094:19]
24460 | | |--IDENT -> verifyWarns [2094:8]
24461 | | |--ELIST -> ELIST [2094:20]
24462 | | | |--EXPR -> EXPR [2094:20]
24463 | | | | `--IDENT -> checkConfig [2094:20]
24464 | | | |--COMMA -> , [2094:31]
24465 | | | |--EXPR -> EXPR [2094:40]
24466 | | | | `--METHOD_CALL -> ( [2094:40]
24467 | | | | |--IDENT -> getPath [2094:33]
24468 | | | | |--ELIST -> ELIST [2094:41]
24469 | | | | | `--EXPR -> EXPR [2094:41]
24470 | | | | | `--STRING_LITERAL -> "InputIndentationValidTryResourcesIndent.java" [2094:41]
24471 | | | | `--RPAREN -> ) [2094:87]
24472 | | | |--COMMA -> , [2094:88]
24473 | | | `--EXPR -> EXPR [2095:15]
24474 | | | `--IDENT -> expected [2095:15]
24475 | | `--RPAREN -> ) [2095:23]
24476 | |--SEMI -> ; [2095:24]
24477 | `--RCURLY -> } [2096:4]
24478 |--METHOD_DEF -> METHOD_DEF [2098:4]
24479 | |--MODIFIERS -> MODIFIERS [2098:4]
24480 | | |--ANNOTATION -> ANNOTATION [2098:4]
24481 | | | |--AT -> @ [2098:4]
24482 | | | `--IDENT -> Test [2098:5]
24483 | | `--LITERAL_PUBLIC -> public [2099:4]
24484 | |--TYPE -> TYPE [2099:11]
24485 | | `--LITERAL_VOID -> void [2099:11]
24486 | |--IDENT -> testSwitchCustom [2099:16]
24487 | |--LPAREN -> ( [2099:32]
24488 | |--PARAMETERS -> PARAMETERS [2099:33]
24489 | |--RPAREN -> ) [2099:33]
24490 | |--LITERAL_THROWS -> throws [2099:35]
24491 | | `--IDENT -> Exception [2099:42]
24492 | `--SLIST -> { [2099:52]
24493 | |--VARIABLE_DEF -> VARIABLE_DEF [2100:8]
24494 | | |--MODIFIERS -> MODIFIERS [2100:8]
24495 | | | `--FINAL -> final [2100:8]
24496 | | |--TYPE -> TYPE [2100:14]
24497 | | | `--IDENT -> DefaultConfiguration [2100:14]
24498 | | |--IDENT -> checkConfig [2100:35]
24499 | | `--ASSIGN -> = [2100:47]
24500 | | `--EXPR -> EXPR [2100:67]
24501 | | `--METHOD_CALL -> ( [2100:67]
24502 | | |--IDENT -> createModuleConfig [2100:49]
24503 | | |--ELIST -> ELIST [2100:84]
24504 | | | `--EXPR -> EXPR [2100:84]
24505 | | | `--DOT -> . [2100:84]
24506 | | | |--IDENT -> IndentationCheck [2100:68]
24507 | | | `--LITERAL_CLASS -> class [2100:85]
24508 | | `--RPAREN -> ) [2100:90]
24509 | |--SEMI -> ; [2100:91]
24510 | |--EXPR -> EXPR [2102:32]
24511 | | `--METHOD_CALL -> ( [2102:32]
24512 | | |--DOT -> . [2102:19]
24513 | | | |--IDENT -> checkConfig [2102:8]
24514 | | | `--IDENT -> addAttribute [2102:20]
24515 | | |--ELIST -> ELIST [2102:33]
24516 | | | |--EXPR -> EXPR [2102:33]
24517 | | | | `--STRING_LITERAL -> "arrayInitIndent" [2102:33]
24518 | | | |--COMMA -> , [2102:50]
24519 | | | `--EXPR -> EXPR [2102:52]
24520 | | | `--STRING_LITERAL -> "4" [2102:52]
24521 | | `--RPAREN -> ) [2102:55]
24522 | |--SEMI -> ; [2102:56]
24523 | |--EXPR -> EXPR [2103:32]
24524 | | `--METHOD_CALL -> ( [2103:32]
24525 | | |--DOT -> . [2103:19]
24526 | | | |--IDENT -> checkConfig [2103:8]
24527 | | | `--IDENT -> addAttribute [2103:20]
24528 | | |--ELIST -> ELIST [2103:33]
24529 | | | |--EXPR -> EXPR [2103:33]
24530 | | | | `--STRING_LITERAL -> "basicOffset" [2103:33]
24531 | | | |--COMMA -> , [2103:46]
24532 | | | `--EXPR -> EXPR [2103:48]
24533 | | | `--STRING_LITERAL -> "4" [2103:48]
24534 | | `--RPAREN -> ) [2103:51]
24535 | |--SEMI -> ; [2103:52]
24536 | |--EXPR -> EXPR [2104:32]
24537 | | `--METHOD_CALL -> ( [2104:32]
24538 | | |--DOT -> . [2104:19]
24539 | | | |--IDENT -> checkConfig [2104:8]
24540 | | | `--IDENT -> addAttribute [2104:20]
24541 | | |--ELIST -> ELIST [2104:33]
24542 | | | |--EXPR -> EXPR [2104:33]
24543 | | | | `--STRING_LITERAL -> "braceAdjustment" [2104:33]
24544 | | | |--COMMA -> , [2104:50]
24545 | | | `--EXPR -> EXPR [2104:52]
24546 | | | `--STRING_LITERAL -> "0" [2104:52]
24547 | | `--RPAREN -> ) [2104:55]
24548 | |--SEMI -> ; [2104:56]
24549 | |--EXPR -> EXPR [2105:32]
24550 | | `--METHOD_CALL -> ( [2105:32]
24551 | | |--DOT -> . [2105:19]
24552 | | | |--IDENT -> checkConfig [2105:8]
24553 | | | `--IDENT -> addAttribute [2105:20]
24554 | | |--ELIST -> ELIST [2105:33]
24555 | | | |--EXPR -> EXPR [2105:33]
24556 | | | | `--STRING_LITERAL -> "caseIndent" [2105:33]
24557 | | | |--COMMA -> , [2105:45]
24558 | | | `--EXPR -> EXPR [2105:47]
24559 | | | `--STRING_LITERAL -> "4" [2105:47]
24560 | | `--RPAREN -> ) [2105:50]
24561 | |--SEMI -> ; [2105:51]
24562 | |--EXPR -> EXPR [2106:32]
24563 | | `--METHOD_CALL -> ( [2106:32]
24564 | | |--DOT -> . [2106:19]
24565 | | | |--IDENT -> checkConfig [2106:8]
24566 | | | `--IDENT -> addAttribute [2106:20]
24567 | | |--ELIST -> ELIST [2106:33]
24568 | | | |--EXPR -> EXPR [2106:33]
24569 | | | | `--STRING_LITERAL -> "forceStrictCondition" [2106:33]
24570 | | | |--COMMA -> , [2106:55]
24571 | | | `--EXPR -> EXPR [2106:57]
24572 | | | `--STRING_LITERAL -> "false" [2106:57]
24573 | | `--RPAREN -> ) [2106:64]
24574 | |--SEMI -> ; [2106:65]
24575 | |--EXPR -> EXPR [2107:32]
24576 | | `--METHOD_CALL -> ( [2107:32]
24577 | | |--DOT -> . [2107:19]
24578 | | | |--IDENT -> checkConfig [2107:8]
24579 | | | `--IDENT -> addAttribute [2107:20]
24580 | | |--ELIST -> ELIST [2107:33]
24581 | | | |--EXPR -> EXPR [2107:33]
24582 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2107:33]
24583 | | | |--COMMA -> , [2107:58]
24584 | | | `--EXPR -> EXPR [2107:60]
24585 | | | `--STRING_LITERAL -> "8" [2107:60]
24586 | | `--RPAREN -> ) [2107:63]
24587 | |--SEMI -> ; [2107:64]
24588 | |--EXPR -> EXPR [2108:32]
24589 | | `--METHOD_CALL -> ( [2108:32]
24590 | | |--DOT -> . [2108:19]
24591 | | | |--IDENT -> checkConfig [2108:8]
24592 | | | `--IDENT -> addAttribute [2108:20]
24593 | | |--ELIST -> ELIST [2108:33]
24594 | | | |--EXPR -> EXPR [2108:33]
24595 | | | | `--STRING_LITERAL -> "tabWidth" [2108:33]
24596 | | | |--COMMA -> , [2108:43]
24597 | | | `--EXPR -> EXPR [2108:45]
24598 | | | `--STRING_LITERAL -> "4" [2108:45]
24599 | | `--RPAREN -> ) [2108:48]
24600 | |--SEMI -> ; [2108:49]
24601 | |--EXPR -> EXPR [2109:32]
24602 | | `--METHOD_CALL -> ( [2109:32]
24603 | | |--DOT -> . [2109:19]
24604 | | | |--IDENT -> checkConfig [2109:8]
24605 | | | `--IDENT -> addAttribute [2109:20]
24606 | | |--ELIST -> ELIST [2109:33]
24607 | | | |--EXPR -> EXPR [2109:33]
24608 | | | | `--STRING_LITERAL -> "throwsIndent" [2109:33]
24609 | | | |--COMMA -> , [2109:47]
24610 | | | `--EXPR -> EXPR [2109:49]
24611 | | | `--STRING_LITERAL -> "8" [2109:49]
24612 | | `--RPAREN -> ) [2109:52]
24613 | |--SEMI -> ; [2109:53]
24614 | |--VARIABLE_DEF -> VARIABLE_DEF [2110:8]
24615 | | |--MODIFIERS -> MODIFIERS [2110:8]
24616 | | | `--FINAL -> final [2110:8]
24617 | | |--TYPE -> TYPE [2110:20]
24618 | | | `--ARRAY_DECLARATOR -> [ [2110:20]
24619 | | | |--IDENT -> String [2110:14]
24620 | | | `--RBRACK -> ] [2110:21]
24621 | | |--IDENT -> expected [2110:23]
24622 | | `--ASSIGN -> = [2110:32]
24623 | | `--EXPR -> EXPR [2110:44]
24624 | | `--DOT -> . [2110:44]
24625 | | |--IDENT -> CommonUtil [2110:34]
24626 | | `--IDENT -> EMPTY_STRING_ARRAY [2110:45]
24627 | |--SEMI -> ; [2110:63]
24628 | |--EXPR -> EXPR [2111:19]
24629 | | `--METHOD_CALL -> ( [2111:19]
24630 | | |--IDENT -> verifyWarns [2111:8]
24631 | | |--ELIST -> ELIST [2111:20]
24632 | | | |--EXPR -> EXPR [2111:20]
24633 | | | | `--IDENT -> checkConfig [2111:20]
24634 | | | |--COMMA -> , [2111:31]
24635 | | | |--EXPR -> EXPR [2111:40]
24636 | | | | `--METHOD_CALL -> ( [2111:40]
24637 | | | | |--IDENT -> getPath [2111:33]
24638 | | | | |--ELIST -> ELIST [2111:41]
24639 | | | | | `--EXPR -> EXPR [2111:41]
24640 | | | | | `--STRING_LITERAL -> "InputIndentationSwitchCustom.java" [2111:41]
24641 | | | | `--RPAREN -> ) [2111:76]
24642 | | | |--COMMA -> , [2111:77]
24643 | | | `--EXPR -> EXPR [2112:15]
24644 | | | `--IDENT -> expected [2112:15]
24645 | | `--RPAREN -> ) [2112:23]
24646 | |--SEMI -> ; [2112:24]
24647 | `--RCURLY -> } [2113:4]
24648 |--METHOD_DEF -> METHOD_DEF [2115:4]
24649 | |--MODIFIERS -> MODIFIERS [2115:4]
24650 | | |--ANNOTATION -> ANNOTATION [2115:4]
24651 | | | |--AT -> @ [2115:4]
24652 | | | `--IDENT -> Test [2115:5]
24653 | | `--LITERAL_PUBLIC -> public [2116:4]
24654 | |--TYPE -> TYPE [2116:11]
24655 | | `--LITERAL_VOID -> void [2116:11]
24656 | |--IDENT -> testSynchronizedStatement [2116:16]
24657 | |--LPAREN -> ( [2116:41]
24658 | |--PARAMETERS -> PARAMETERS [2116:42]
24659 | |--RPAREN -> ) [2116:42]
24660 | |--LITERAL_THROWS -> throws [2116:44]
24661 | | `--IDENT -> Exception [2116:51]
24662 | `--SLIST -> { [2116:61]
24663 | |--VARIABLE_DEF -> VARIABLE_DEF [2117:8]
24664 | | |--MODIFIERS -> MODIFIERS [2117:8]
24665 | | | `--FINAL -> final [2117:8]
24666 | | |--TYPE -> TYPE [2117:14]
24667 | | | `--IDENT -> DefaultConfiguration [2117:14]
24668 | | |--IDENT -> checkConfig [2117:35]
24669 | | `--ASSIGN -> = [2117:47]
24670 | | `--EXPR -> EXPR [2117:67]
24671 | | `--METHOD_CALL -> ( [2117:67]
24672 | | |--IDENT -> createModuleConfig [2117:49]
24673 | | |--ELIST -> ELIST [2117:84]
24674 | | | `--EXPR -> EXPR [2117:84]
24675 | | | `--DOT -> . [2117:84]
24676 | | | |--IDENT -> IndentationCheck [2117:68]
24677 | | | `--LITERAL_CLASS -> class [2117:85]
24678 | | `--RPAREN -> ) [2117:90]
24679 | |--SEMI -> ; [2117:91]
24680 | |--EXPR -> EXPR [2118:32]
24681 | | `--METHOD_CALL -> ( [2118:32]
24682 | | |--DOT -> . [2118:19]
24683 | | | |--IDENT -> checkConfig [2118:8]
24684 | | | `--IDENT -> addAttribute [2118:20]
24685 | | |--ELIST -> ELIST [2118:33]
24686 | | | |--EXPR -> EXPR [2118:33]
24687 | | | | `--STRING_LITERAL -> "arrayInitIndent" [2118:33]
24688 | | | |--COMMA -> , [2118:50]
24689 | | | `--EXPR -> EXPR [2118:52]
24690 | | | `--STRING_LITERAL -> "4" [2118:52]
24691 | | `--RPAREN -> ) [2118:55]
24692 | |--SEMI -> ; [2118:56]
24693 | |--EXPR -> EXPR [2119:32]
24694 | | `--METHOD_CALL -> ( [2119:32]
24695 | | |--DOT -> . [2119:19]
24696 | | | |--IDENT -> checkConfig [2119:8]
24697 | | | `--IDENT -> addAttribute [2119:20]
24698 | | |--ELIST -> ELIST [2119:33]
24699 | | | |--EXPR -> EXPR [2119:33]
24700 | | | | `--STRING_LITERAL -> "basicOffset" [2119:33]
24701 | | | |--COMMA -> , [2119:46]
24702 | | | `--EXPR -> EXPR [2119:48]
24703 | | | `--STRING_LITERAL -> "4" [2119:48]
24704 | | `--RPAREN -> ) [2119:51]
24705 | |--SEMI -> ; [2119:52]
24706 | |--EXPR -> EXPR [2120:32]
24707 | | `--METHOD_CALL -> ( [2120:32]
24708 | | |--DOT -> . [2120:19]
24709 | | | |--IDENT -> checkConfig [2120:8]
24710 | | | `--IDENT -> addAttribute [2120:20]
24711 | | |--ELIST -> ELIST [2120:33]
24712 | | | |--EXPR -> EXPR [2120:33]
24713 | | | | `--STRING_LITERAL -> "braceAdjustment" [2120:33]
24714 | | | |--COMMA -> , [2120:50]
24715 | | | `--EXPR -> EXPR [2120:52]
24716 | | | `--STRING_LITERAL -> "0" [2120:52]
24717 | | `--RPAREN -> ) [2120:55]
24718 | |--SEMI -> ; [2120:56]
24719 | |--EXPR -> EXPR [2121:32]
24720 | | `--METHOD_CALL -> ( [2121:32]
24721 | | |--DOT -> . [2121:19]
24722 | | | |--IDENT -> checkConfig [2121:8]
24723 | | | `--IDENT -> addAttribute [2121:20]
24724 | | |--ELIST -> ELIST [2121:33]
24725 | | | |--EXPR -> EXPR [2121:33]
24726 | | | | `--STRING_LITERAL -> "caseIndent" [2121:33]
24727 | | | |--COMMA -> , [2121:45]
24728 | | | `--EXPR -> EXPR [2121:47]
24729 | | | `--STRING_LITERAL -> "4" [2121:47]
24730 | | `--RPAREN -> ) [2121:50]
24731 | |--SEMI -> ; [2121:51]
24732 | |--EXPR -> EXPR [2122:32]
24733 | | `--METHOD_CALL -> ( [2122:32]
24734 | | |--DOT -> . [2122:19]
24735 | | | |--IDENT -> checkConfig [2122:8]
24736 | | | `--IDENT -> addAttribute [2122:20]
24737 | | |--ELIST -> ELIST [2122:33]
24738 | | | |--EXPR -> EXPR [2122:33]
24739 | | | | `--STRING_LITERAL -> "forceStrictCondition" [2122:33]
24740 | | | |--COMMA -> , [2122:55]
24741 | | | `--EXPR -> EXPR [2122:57]
24742 | | | `--STRING_LITERAL -> "false" [2122:57]
24743 | | `--RPAREN -> ) [2122:64]
24744 | |--SEMI -> ; [2122:65]
24745 | |--EXPR -> EXPR [2123:32]
24746 | | `--METHOD_CALL -> ( [2123:32]
24747 | | |--DOT -> . [2123:19]
24748 | | | |--IDENT -> checkConfig [2123:8]
24749 | | | `--IDENT -> addAttribute [2123:20]
24750 | | |--ELIST -> ELIST [2123:33]
24751 | | | |--EXPR -> EXPR [2123:33]
24752 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2123:33]
24753 | | | |--COMMA -> , [2123:58]
24754 | | | `--EXPR -> EXPR [2123:60]
24755 | | | `--STRING_LITERAL -> "8" [2123:60]
24756 | | `--RPAREN -> ) [2123:63]
24757 | |--SEMI -> ; [2123:64]
24758 | |--EXPR -> EXPR [2124:32]
24759 | | `--METHOD_CALL -> ( [2124:32]
24760 | | |--DOT -> . [2124:19]
24761 | | | |--IDENT -> checkConfig [2124:8]
24762 | | | `--IDENT -> addAttribute [2124:20]
24763 | | |--ELIST -> ELIST [2124:33]
24764 | | | |--EXPR -> EXPR [2124:33]
24765 | | | | `--STRING_LITERAL -> "tabWidth" [2124:33]
24766 | | | |--COMMA -> , [2124:43]
24767 | | | `--EXPR -> EXPR [2124:45]
24768 | | | `--STRING_LITERAL -> "4" [2124:45]
24769 | | `--RPAREN -> ) [2124:48]
24770 | |--SEMI -> ; [2124:49]
24771 | |--EXPR -> EXPR [2125:32]
24772 | | `--METHOD_CALL -> ( [2125:32]
24773 | | |--DOT -> . [2125:19]
24774 | | | |--IDENT -> checkConfig [2125:8]
24775 | | | `--IDENT -> addAttribute [2125:20]
24776 | | |--ELIST -> ELIST [2125:33]
24777 | | | |--EXPR -> EXPR [2125:33]
24778 | | | | `--STRING_LITERAL -> "throwsIndent" [2125:33]
24779 | | | |--COMMA -> , [2125:47]
24780 | | | `--EXPR -> EXPR [2125:49]
24781 | | | `--STRING_LITERAL -> "8" [2125:49]
24782 | | `--RPAREN -> ) [2125:52]
24783 | |--SEMI -> ; [2125:53]
24784 | |--VARIABLE_DEF -> VARIABLE_DEF [2126:8]
24785 | | |--MODIFIERS -> MODIFIERS [2126:8]
24786 | | | `--FINAL -> final [2126:8]
24787 | | |--TYPE -> TYPE [2126:20]
24788 | | | `--ARRAY_DECLARATOR -> [ [2126:20]
24789 | | | |--IDENT -> String [2126:14]
24790 | | | `--RBRACK -> ] [2126:21]
24791 | | |--IDENT -> expected [2126:23]
24792 | | `--ASSIGN -> = [2126:32]
24793 | | `--ARRAY_INIT -> { [2126:34]
24794 | | |--EXPR -> EXPR [2127:21]
24795 | | | `--PLUS -> + [2127:21]
24796 | | | |--STRING_LITERAL -> "27:1: " [2127:12]
24797 | | | `--METHOD_CALL -> ( [2127:38]
24798 | | | |--IDENT -> getCheckMessage [2127:23]
24799 | | | |--ELIST -> ELIST [2127:39]
24800 | | | | |--EXPR -> EXPR [2127:39]
24801 | | | | | `--IDENT -> MSG_CHILD_ERROR [2127:39]
24802 | | | | |--COMMA -> , [2127:54]
24803 | | | | |--EXPR -> EXPR [2127:56]
24804 | | | | | `--STRING_LITERAL -> "synchronized" [2127:56]
24805 | | | | |--COMMA -> , [2127:70]
24806 | | | | |--EXPR -> EXPR [2127:72]
24807 | | | | | `--NUM_INT -> 0 [2127:72]
24808 | | | | |--COMMA -> , [2127:73]
24809 | | | | `--EXPR -> EXPR [2127:75]
24810 | | | | `--NUM_INT -> 12 [2127:75]
24811 | | | `--RPAREN -> ) [2127:77]
24812 | | |--COMMA -> , [2127:78]
24813 | | |--EXPR -> EXPR [2128:22]
24814 | | | `--PLUS -> + [2128:22]
24815 | | | |--STRING_LITERAL -> "30:13: " [2128:12]
24816 | | | `--METHOD_CALL -> ( [2128:39]
24817 | | | |--IDENT -> getCheckMessage [2128:24]
24818 | | | |--ELIST -> ELIST [2128:40]
24819 | | | | |--EXPR -> EXPR [2128:40]
24820 | | | | | `--IDENT -> MSG_ERROR [2128:40]
24821 | | | | |--COMMA -> , [2128:49]
24822 | | | | |--EXPR -> EXPR [2128:51]
24823 | | | | | `--STRING_LITERAL -> "synchronized lparen" [2128:51]
24824 | | | | |--COMMA -> , [2128:72]
24825 | | | | |--EXPR -> EXPR [2128:74]
24826 | | | | | `--NUM_INT -> 12 [2128:74]
24827 | | | | |--COMMA -> , [2128:76]
24828 | | | | `--EXPR -> EXPR [2128:78]
24829 | | | | `--NUM_INT -> 8 [2128:78]
24830 | | | `--RPAREN -> ) [2128:79]
24831 | | |--COMMA -> , [2128:80]
24832 | | `--RCURLY -> } [2129:8]
24833 | |--SEMI -> ; [2129:9]
24834 | |--EXPR -> EXPR [2130:19]
24835 | | `--METHOD_CALL -> ( [2130:19]
24836 | | |--IDENT -> verifyWarns [2130:8]
24837 | | |--ELIST -> ELIST [2130:20]
24838 | | | |--EXPR -> EXPR [2130:20]
24839 | | | | `--IDENT -> checkConfig [2130:20]
24840 | | | |--COMMA -> , [2130:31]
24841 | | | |--EXPR -> EXPR [2130:40]
24842 | | | | `--METHOD_CALL -> ( [2130:40]
24843 | | | | |--IDENT -> getPath [2130:33]
24844 | | | | |--ELIST -> ELIST [2130:41]
24845 | | | | | `--EXPR -> EXPR [2130:41]
24846 | | | | | `--STRING_LITERAL -> "InputIndentationSynchronizedStatement.java" [2130:41]
24847 | | | | `--RPAREN -> ) [2130:85]
24848 | | | |--COMMA -> , [2130:86]
24849 | | | `--EXPR -> EXPR [2130:88]
24850 | | | `--IDENT -> expected [2130:88]
24851 | | `--RPAREN -> ) [2130:96]
24852 | |--SEMI -> ; [2130:97]
24853 | `--RCURLY -> } [2131:4]
24854 |--METHOD_DEF -> METHOD_DEF [2133:4]
24855 | |--MODIFIERS -> MODIFIERS [2133:4]
24856 | | |--ANNOTATION -> ANNOTATION [2133:4]
24857 | | | |--AT -> @ [2133:4]
24858 | | | `--IDENT -> Test [2133:5]
24859 | | `--LITERAL_PUBLIC -> public [2134:4]
24860 | |--TYPE -> TYPE [2134:11]
24861 | | `--LITERAL_VOID -> void [2134:11]
24862 | |--IDENT -> testSynchronizedMethod [2134:16]
24863 | |--LPAREN -> ( [2134:38]
24864 | |--PARAMETERS -> PARAMETERS [2134:39]
24865 | |--RPAREN -> ) [2134:39]
24866 | |--LITERAL_THROWS -> throws [2134:41]
24867 | | `--IDENT -> Exception [2134:48]
24868 | `--SLIST -> { [2134:58]
24869 | |--VARIABLE_DEF -> VARIABLE_DEF [2135:8]
24870 | | |--MODIFIERS -> MODIFIERS [2135:8]
24871 | | | `--FINAL -> final [2135:8]
24872 | | |--TYPE -> TYPE [2135:14]
24873 | | | `--IDENT -> DefaultConfiguration [2135:14]
24874 | | |--IDENT -> checkConfig [2135:35]
24875 | | `--ASSIGN -> = [2135:47]
24876 | | `--EXPR -> EXPR [2135:67]
24877 | | `--METHOD_CALL -> ( [2135:67]
24878 | | |--IDENT -> createModuleConfig [2135:49]
24879 | | |--ELIST -> ELIST [2135:84]
24880 | | | `--EXPR -> EXPR [2135:84]
24881 | | | `--DOT -> . [2135:84]
24882 | | | |--IDENT -> IndentationCheck [2135:68]
24883 | | | `--LITERAL_CLASS -> class [2135:85]
24884 | | `--RPAREN -> ) [2135:90]
24885 | |--SEMI -> ; [2135:91]
24886 | |--EXPR -> EXPR [2136:32]
24887 | | `--METHOD_CALL -> ( [2136:32]
24888 | | |--DOT -> . [2136:19]
24889 | | | |--IDENT -> checkConfig [2136:8]
24890 | | | `--IDENT -> addAttribute [2136:20]
24891 | | |--ELIST -> ELIST [2136:33]
24892 | | | |--EXPR -> EXPR [2136:33]
24893 | | | | `--STRING_LITERAL -> "arrayInitIndent" [2136:33]
24894 | | | |--COMMA -> , [2136:50]
24895 | | | `--EXPR -> EXPR [2136:52]
24896 | | | `--STRING_LITERAL -> "4" [2136:52]
24897 | | `--RPAREN -> ) [2136:55]
24898 | |--SEMI -> ; [2136:56]
24899 | |--EXPR -> EXPR [2137:32]
24900 | | `--METHOD_CALL -> ( [2137:32]
24901 | | |--DOT -> . [2137:19]
24902 | | | |--IDENT -> checkConfig [2137:8]
24903 | | | `--IDENT -> addAttribute [2137:20]
24904 | | |--ELIST -> ELIST [2137:33]
24905 | | | |--EXPR -> EXPR [2137:33]
24906 | | | | `--STRING_LITERAL -> "basicOffset" [2137:33]
24907 | | | |--COMMA -> , [2137:46]
24908 | | | `--EXPR -> EXPR [2137:48]
24909 | | | `--STRING_LITERAL -> "4" [2137:48]
24910 | | `--RPAREN -> ) [2137:51]
24911 | |--SEMI -> ; [2137:52]
24912 | |--EXPR -> EXPR [2138:32]
24913 | | `--METHOD_CALL -> ( [2138:32]
24914 | | |--DOT -> . [2138:19]
24915 | | | |--IDENT -> checkConfig [2138:8]
24916 | | | `--IDENT -> addAttribute [2138:20]
24917 | | |--ELIST -> ELIST [2138:33]
24918 | | | |--EXPR -> EXPR [2138:33]
24919 | | | | `--STRING_LITERAL -> "braceAdjustment" [2138:33]
24920 | | | |--COMMA -> , [2138:50]
24921 | | | `--EXPR -> EXPR [2138:52]
24922 | | | `--STRING_LITERAL -> "0" [2138:52]
24923 | | `--RPAREN -> ) [2138:55]
24924 | |--SEMI -> ; [2138:56]
24925 | |--EXPR -> EXPR [2139:32]
24926 | | `--METHOD_CALL -> ( [2139:32]
24927 | | |--DOT -> . [2139:19]
24928 | | | |--IDENT -> checkConfig [2139:8]
24929 | | | `--IDENT -> addAttribute [2139:20]
24930 | | |--ELIST -> ELIST [2139:33]
24931 | | | |--EXPR -> EXPR [2139:33]
24932 | | | | `--STRING_LITERAL -> "caseIndent" [2139:33]
24933 | | | |--COMMA -> , [2139:45]
24934 | | | `--EXPR -> EXPR [2139:47]
24935 | | | `--STRING_LITERAL -> "4" [2139:47]
24936 | | `--RPAREN -> ) [2139:50]
24937 | |--SEMI -> ; [2139:51]
24938 | |--EXPR -> EXPR [2140:32]
24939 | | `--METHOD_CALL -> ( [2140:32]
24940 | | |--DOT -> . [2140:19]
24941 | | | |--IDENT -> checkConfig [2140:8]
24942 | | | `--IDENT -> addAttribute [2140:20]
24943 | | |--ELIST -> ELIST [2140:33]
24944 | | | |--EXPR -> EXPR [2140:33]
24945 | | | | `--STRING_LITERAL -> "forceStrictCondition" [2140:33]
24946 | | | |--COMMA -> , [2140:55]
24947 | | | `--EXPR -> EXPR [2140:57]
24948 | | | `--STRING_LITERAL -> "false" [2140:57]
24949 | | `--RPAREN -> ) [2140:64]
24950 | |--SEMI -> ; [2140:65]
24951 | |--EXPR -> EXPR [2141:32]
24952 | | `--METHOD_CALL -> ( [2141:32]
24953 | | |--DOT -> . [2141:19]
24954 | | | |--IDENT -> checkConfig [2141:8]
24955 | | | `--IDENT -> addAttribute [2141:20]
24956 | | |--ELIST -> ELIST [2141:33]
24957 | | | |--EXPR -> EXPR [2141:33]
24958 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2141:33]
24959 | | | |--COMMA -> , [2141:58]
24960 | | | `--EXPR -> EXPR [2141:60]
24961 | | | `--STRING_LITERAL -> "8" [2141:60]
24962 | | `--RPAREN -> ) [2141:63]
24963 | |--SEMI -> ; [2141:64]
24964 | |--EXPR -> EXPR [2142:32]
24965 | | `--METHOD_CALL -> ( [2142:32]
24966 | | |--DOT -> . [2142:19]
24967 | | | |--IDENT -> checkConfig [2142:8]
24968 | | | `--IDENT -> addAttribute [2142:20]
24969 | | |--ELIST -> ELIST [2142:33]
24970 | | | |--EXPR -> EXPR [2142:33]
24971 | | | | `--STRING_LITERAL -> "tabWidth" [2142:33]
24972 | | | |--COMMA -> , [2142:43]
24973 | | | `--EXPR -> EXPR [2142:45]
24974 | | | `--STRING_LITERAL -> "4" [2142:45]
24975 | | `--RPAREN -> ) [2142:48]
24976 | |--SEMI -> ; [2142:49]
24977 | |--EXPR -> EXPR [2143:32]
24978 | | `--METHOD_CALL -> ( [2143:32]
24979 | | |--DOT -> . [2143:19]
24980 | | | |--IDENT -> checkConfig [2143:8]
24981 | | | `--IDENT -> addAttribute [2143:20]
24982 | | |--ELIST -> ELIST [2143:33]
24983 | | | |--EXPR -> EXPR [2143:33]
24984 | | | | `--STRING_LITERAL -> "throwsIndent" [2143:33]
24985 | | | |--COMMA -> , [2143:47]
24986 | | | `--EXPR -> EXPR [2143:49]
24987 | | | `--STRING_LITERAL -> "8" [2143:49]
24988 | | `--RPAREN -> ) [2143:52]
24989 | |--SEMI -> ; [2143:53]
24990 | |--VARIABLE_DEF -> VARIABLE_DEF [2144:8]
24991 | | |--MODIFIERS -> MODIFIERS [2144:8]
24992 | | | `--FINAL -> final [2144:8]
24993 | | |--TYPE -> TYPE [2144:20]
24994 | | | `--ARRAY_DECLARATOR -> [ [2144:20]
24995 | | | |--IDENT -> String [2144:14]
24996 | | | `--RBRACK -> ] [2144:21]
24997 | | |--IDENT -> expected [2144:23]
24998 | | `--ASSIGN -> = [2144:32]
24999 | | `--EXPR -> EXPR [2144:44]
25000 | | `--DOT -> . [2144:44]
25001 | | |--IDENT -> CommonUtil [2144:34]
25002 | | `--IDENT -> EMPTY_STRING_ARRAY [2144:45]
25003 | |--SEMI -> ; [2144:63]
25004 | |--EXPR -> EXPR [2145:19]
25005 | | `--METHOD_CALL -> ( [2145:19]
25006 | | |--IDENT -> verifyWarns [2145:8]
25007 | | |--ELIST -> ELIST [2145:20]
25008 | | | |--EXPR -> EXPR [2145:20]
25009 | | | | `--IDENT -> checkConfig [2145:20]
25010 | | | |--COMMA -> , [2145:31]
25011 | | | |--EXPR -> EXPR [2145:40]
25012 | | | | `--METHOD_CALL -> ( [2145:40]
25013 | | | | |--IDENT -> getPath [2145:33]
25014 | | | | |--ELIST -> ELIST [2145:41]
25015 | | | | | `--EXPR -> EXPR [2145:41]
25016 | | | | | `--STRING_LITERAL -> "InputIndentationSynchronizedMethod.java" [2145:41]
25017 | | | | `--RPAREN -> ) [2145:82]
25018 | | | |--COMMA -> , [2145:83]
25019 | | | `--EXPR -> EXPR [2145:85]
25020 | | | `--IDENT -> expected [2145:85]
25021 | | `--RPAREN -> ) [2145:93]
25022 | |--SEMI -> ; [2145:94]
25023 | `--RCURLY -> } [2146:4]
25024 |--METHOD_DEF -> METHOD_DEF [2148:4]
25025 | |--MODIFIERS -> MODIFIERS [2148:4]
25026 | | |--ANNOTATION -> ANNOTATION [2148:4]
25027 | | | |--AT -> @ [2148:4]
25028 | | | `--IDENT -> Test [2148:5]
25029 | | `--LITERAL_PUBLIC -> public [2149:4]
25030 | |--TYPE -> TYPE [2149:11]
25031 | | `--LITERAL_VOID -> void [2149:11]
25032 | |--IDENT -> testAnonymousClassInMethod [2149:16]
25033 | |--LPAREN -> ( [2149:42]
25034 | |--PARAMETERS -> PARAMETERS [2149:43]
25035 | |--RPAREN -> ) [2149:43]
25036 | |--LITERAL_THROWS -> throws [2149:45]
25037 | | `--IDENT -> Exception [2149:52]
25038 | `--SLIST -> { [2149:62]
25039 | |--VARIABLE_DEF -> VARIABLE_DEF [2150:8]
25040 | | |--MODIFIERS -> MODIFIERS [2150:8]
25041 | | | `--FINAL -> final [2150:8]
25042 | | |--TYPE -> TYPE [2150:14]
25043 | | | `--IDENT -> DefaultConfiguration [2150:14]
25044 | | |--IDENT -> checkConfig [2150:35]
25045 | | `--ASSIGN -> = [2150:47]
25046 | | `--EXPR -> EXPR [2150:67]
25047 | | `--METHOD_CALL -> ( [2150:67]
25048 | | |--IDENT -> createModuleConfig [2150:49]
25049 | | |--ELIST -> ELIST [2150:84]
25050 | | | `--EXPR -> EXPR [2150:84]
25051 | | | `--DOT -> . [2150:84]
25052 | | | |--IDENT -> IndentationCheck [2150:68]
25053 | | | `--LITERAL_CLASS -> class [2150:85]
25054 | | `--RPAREN -> ) [2150:90]
25055 | |--SEMI -> ; [2150:91]
25056 | |--EXPR -> EXPR [2151:32]
25057 | | `--METHOD_CALL -> ( [2151:32]
25058 | | |--DOT -> . [2151:19]
25059 | | | |--IDENT -> checkConfig [2151:8]
25060 | | | `--IDENT -> addAttribute [2151:20]
25061 | | |--ELIST -> ELIST [2151:33]
25062 | | | |--EXPR -> EXPR [2151:33]
25063 | | | | `--STRING_LITERAL -> "tabWidth" [2151:33]
25064 | | | |--COMMA -> , [2151:43]
25065 | | | `--EXPR -> EXPR [2151:45]
25066 | | | `--STRING_LITERAL -> "8" [2151:45]
25067 | | `--RPAREN -> ) [2151:48]
25068 | |--SEMI -> ; [2151:49]
25069 | |--EXPR -> EXPR [2152:32]
25070 | | `--METHOD_CALL -> ( [2152:32]
25071 | | |--DOT -> . [2152:19]
25072 | | | |--IDENT -> checkConfig [2152:8]
25073 | | | `--IDENT -> addAttribute [2152:20]
25074 | | |--ELIST -> ELIST [2152:33]
25075 | | | |--EXPR -> EXPR [2152:33]
25076 | | | | `--STRING_LITERAL -> "basicOffset" [2152:33]
25077 | | | |--COMMA -> , [2152:46]
25078 | | | `--EXPR -> EXPR [2152:48]
25079 | | | `--STRING_LITERAL -> "2" [2152:48]
25080 | | `--RPAREN -> ) [2152:51]
25081 | |--SEMI -> ; [2152:52]
25082 | |--EXPR -> EXPR [2153:32]
25083 | | `--METHOD_CALL -> ( [2153:32]
25084 | | |--DOT -> . [2153:19]
25085 | | | |--IDENT -> checkConfig [2153:8]
25086 | | | `--IDENT -> addAttribute [2153:20]
25087 | | |--ELIST -> ELIST [2153:33]
25088 | | | |--EXPR -> EXPR [2153:33]
25089 | | | | `--STRING_LITERAL -> "braceAdjustment" [2153:33]
25090 | | | |--COMMA -> , [2153:50]
25091 | | | `--EXPR -> EXPR [2153:52]
25092 | | | `--STRING_LITERAL -> "0" [2153:52]
25093 | | `--RPAREN -> ) [2153:55]
25094 | |--SEMI -> ; [2153:56]
25095 | |--EXPR -> EXPR [2154:32]
25096 | | `--METHOD_CALL -> ( [2154:32]
25097 | | |--DOT -> . [2154:19]
25098 | | | |--IDENT -> checkConfig [2154:8]
25099 | | | `--IDENT -> addAttribute [2154:20]
25100 | | |--ELIST -> ELIST [2154:33]
25101 | | | |--EXPR -> EXPR [2154:33]
25102 | | | | `--STRING_LITERAL -> "caseIndent" [2154:33]
25103 | | | |--COMMA -> , [2154:45]
25104 | | | `--EXPR -> EXPR [2154:47]
25105 | | | `--STRING_LITERAL -> "2" [2154:47]
25106 | | `--RPAREN -> ) [2154:50]
25107 | |--SEMI -> ; [2154:51]
25108 | |--EXPR -> EXPR [2155:32]
25109 | | `--METHOD_CALL -> ( [2155:32]
25110 | | |--DOT -> . [2155:19]
25111 | | | |--IDENT -> checkConfig [2155:8]
25112 | | | `--IDENT -> addAttribute [2155:20]
25113 | | |--ELIST -> ELIST [2155:33]
25114 | | | |--EXPR -> EXPR [2155:33]
25115 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2155:33]
25116 | | | |--COMMA -> , [2155:58]
25117 | | | `--EXPR -> EXPR [2155:60]
25118 | | | `--STRING_LITERAL -> "4" [2155:60]
25119 | | `--RPAREN -> ) [2155:63]
25120 | |--SEMI -> ; [2155:64]
25121 | |--EXPR -> EXPR [2156:32]
25122 | | `--METHOD_CALL -> ( [2156:32]
25123 | | |--DOT -> . [2156:19]
25124 | | | |--IDENT -> checkConfig [2156:8]
25125 | | | `--IDENT -> addAttribute [2156:20]
25126 | | |--ELIST -> ELIST [2156:33]
25127 | | | |--EXPR -> EXPR [2156:33]
25128 | | | | `--STRING_LITERAL -> "throwsIndent" [2156:33]
25129 | | | |--COMMA -> , [2156:47]
25130 | | | `--EXPR -> EXPR [2156:49]
25131 | | | `--STRING_LITERAL -> "4" [2156:49]
25132 | | `--RPAREN -> ) [2156:52]
25133 | |--SEMI -> ; [2156:53]
25134 | |--EXPR -> EXPR [2157:32]
25135 | | `--METHOD_CALL -> ( [2157:32]
25136 | | |--DOT -> . [2157:19]
25137 | | | |--IDENT -> checkConfig [2157:8]
25138 | | | `--IDENT -> addAttribute [2157:20]
25139 | | |--ELIST -> ELIST [2157:33]
25140 | | | |--EXPR -> EXPR [2157:33]
25141 | | | | `--STRING_LITERAL -> "arrayInitIndent" [2157:33]
25142 | | | |--COMMA -> , [2157:50]
25143 | | | `--EXPR -> EXPR [2157:52]
25144 | | | `--STRING_LITERAL -> "2" [2157:52]
25145 | | `--RPAREN -> ) [2157:55]
25146 | |--SEMI -> ; [2157:56]
25147 | |--VARIABLE_DEF -> VARIABLE_DEF [2158:8]
25148 | | |--MODIFIERS -> MODIFIERS [2158:8]
25149 | | | `--FINAL -> final [2158:8]
25150 | | |--TYPE -> TYPE [2158:20]
25151 | | | `--ARRAY_DECLARATOR -> [ [2158:20]
25152 | | | |--IDENT -> String [2158:14]
25153 | | | `--RBRACK -> ] [2158:21]
25154 | | |--IDENT -> expected [2158:23]
25155 | | `--ASSIGN -> = [2158:32]
25156 | | `--ARRAY_INIT -> { [2158:34]
25157 | | |--EXPR -> EXPR [2159:21]
25158 | | | `--PLUS -> + [2159:21]
25159 | | | |--STRING_LITERAL -> "19:9: " [2159:12]
25160 | | | `--METHOD_CALL -> ( [2159:38]
25161 | | | |--IDENT -> getCheckMessage [2159:23]
25162 | | | |--ELIST -> ELIST [2159:39]
25163 | | | | |--EXPR -> EXPR [2159:39]
25164 | | | | | `--IDENT -> MSG_ERROR [2159:39]
25165 | | | | |--COMMA -> , [2159:48]
25166 | | | | |--EXPR -> EXPR [2159:50]
25167 | | | | | `--STRING_LITERAL -> "method def modifier" [2159:50]
25168 | | | | |--COMMA -> , [2159:71]
25169 | | | | |--EXPR -> EXPR [2159:73]
25170 | | | | | `--NUM_INT -> 8 [2159:73]
25171 | | | | |--COMMA -> , [2159:74]
25172 | | | | `--EXPR -> EXPR [2159:76]
25173 | | | | `--NUM_INT -> 2 [2159:76]
25174 | | | `--RPAREN -> ) [2159:77]
25175 | | |--COMMA -> , [2159:78]
25176 | | |--EXPR -> EXPR [2160:22]
25177 | | | `--PLUS -> + [2160:22]
25178 | | | |--STRING_LITERAL -> "20:17: " [2160:12]
25179 | | | `--METHOD_CALL -> ( [2160:39]
25180 | | | |--IDENT -> getCheckMessage [2160:24]
25181 | | | |--ELIST -> ELIST [2160:40]
25182 | | | | |--EXPR -> EXPR [2160:40]
25183 | | | | | `--IDENT -> MSG_CHILD_ERROR [2160:40]
25184 | | | | |--COMMA -> , [2160:55]
25185 | | | | |--EXPR -> EXPR [2160:57]
25186 | | | | | `--STRING_LITERAL -> "method def" [2160:57]
25187 | | | | |--COMMA -> , [2160:69]
25188 | | | | |--EXPR -> EXPR [2160:71]
25189 | | | | | `--NUM_INT -> 16 [2160:71]
25190 | | | | |--COMMA -> , [2160:73]
25191 | | | | `--EXPR -> EXPR [2160:75]
25192 | | | | `--NUM_INT -> 4 [2160:75]
25193 | | | `--RPAREN -> ) [2160:76]
25194 | | |--COMMA -> , [2160:77]
25195 | | |--EXPR -> EXPR [2161:22]
25196 | | | `--PLUS -> + [2161:22]
25197 | | | |--STRING_LITERAL -> "21:25: " [2161:12]
25198 | | | `--METHOD_CALL -> ( [2161:39]
25199 | | | |--IDENT -> getCheckMessage [2161:24]
25200 | | | |--ELIST -> ELIST [2161:40]
25201 | | | | |--EXPR -> EXPR [2161:40]
25202 | | | | | `--IDENT -> MSG_ERROR_MULTI [2161:40]
25203 | | | | |--COMMA -> , [2161:55]
25204 | | | | |--EXPR -> EXPR [2161:57]
25205 | | | | | `--STRING_LITERAL -> "method def modifier" [2161:57]
25206 | | | | |--COMMA -> , [2161:78]
25207 | | | | |--EXPR -> EXPR [2161:80]
25208 | | | | | `--NUM_INT -> 24 [2161:80]
25209 | | | | |--COMMA -> , [2161:82]
25210 | | | | `--EXPR -> EXPR [2161:84]
25211 | | | | `--STRING_LITERAL -> "18, 20, 22" [2161:84]
25212 | | | `--RPAREN -> ) [2161:96]
25213 | | |--COMMA -> , [2161:97]
25214 | | |--EXPR -> EXPR [2162:22]
25215 | | | `--PLUS -> + [2162:22]
25216 | | | |--STRING_LITERAL -> "23:33: " [2162:12]
25217 | | | `--METHOD_CALL -> ( [2162:39]
25218 | | | |--IDENT -> getCheckMessage [2162:24]
25219 | | | |--ELIST -> ELIST [2162:40]
25220 | | | | |--EXPR -> EXPR [2162:40]
25221 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [2162:40]
25222 | | | | |--COMMA -> , [2162:61]
25223 | | | | |--EXPR -> EXPR [2162:63]
25224 | | | | | `--STRING_LITERAL -> "method def" [2162:63]
25225 | | | | |--COMMA -> , [2162:75]
25226 | | | | |--EXPR -> EXPR [2162:77]
25227 | | | | | `--NUM_INT -> 32 [2162:77]
25228 | | | | |--COMMA -> , [2162:79]
25229 | | | | `--EXPR -> EXPR [2162:81]
25230 | | | | `--STRING_LITERAL -> "20, 22, 24" [2162:81]
25231 | | | `--RPAREN -> ) [2162:93]
25232 | | |--COMMA -> , [2162:94]
25233 | | |--EXPR -> EXPR [2163:22]
25234 | | | `--PLUS -> + [2163:22]
25235 | | | |--STRING_LITERAL -> "24:25: " [2163:12]
25236 | | | `--METHOD_CALL -> ( [2163:39]
25237 | | | |--IDENT -> getCheckMessage [2163:24]
25238 | | | |--ELIST -> ELIST [2163:40]
25239 | | | | |--EXPR -> EXPR [2163:40]
25240 | | | | | `--IDENT -> MSG_ERROR_MULTI [2163:40]
25241 | | | | |--COMMA -> , [2163:55]
25242 | | | | |--EXPR -> EXPR [2163:57]
25243 | | | | | `--STRING_LITERAL -> "method def rcurly" [2163:57]
25244 | | | | |--COMMA -> , [2163:76]
25245 | | | | |--EXPR -> EXPR [2163:78]
25246 | | | | | `--NUM_INT -> 24 [2163:78]
25247 | | | | |--COMMA -> , [2163:80]
25248 | | | | `--EXPR -> EXPR [2163:82]
25249 | | | | `--STRING_LITERAL -> "18, 20, 22" [2163:82]
25250 | | | `--RPAREN -> ) [2163:94]
25251 | | |--COMMA -> , [2163:95]
25252 | | |--EXPR -> EXPR [2164:21]
25253 | | | `--PLUS -> + [2164:21]
25254 | | | |--STRING_LITERAL -> "26:9: " [2164:12]
25255 | | | `--METHOD_CALL -> ( [2164:38]
25256 | | | |--IDENT -> getCheckMessage [2164:23]
25257 | | | |--ELIST -> ELIST [2164:39]
25258 | | | | |--EXPR -> EXPR [2164:39]
25259 | | | | | `--IDENT -> MSG_ERROR [2164:39]
25260 | | | | |--COMMA -> , [2164:48]
25261 | | | | |--EXPR -> EXPR [2164:50]
25262 | | | | | `--STRING_LITERAL -> "method def rcurly" [2164:50]
25263 | | | | |--COMMA -> , [2164:69]
25264 | | | | |--EXPR -> EXPR [2164:71]
25265 | | | | | `--NUM_INT -> 8 [2164:71]
25266 | | | | |--COMMA -> , [2164:72]
25267 | | | | `--EXPR -> EXPR [2164:74]
25268 | | | | `--NUM_INT -> 2 [2164:74]
25269 | | | `--RPAREN -> ) [2164:75]
25270 | | |--COMMA -> , [2164:76]
25271 | | `--RCURLY -> } [2165:8]
25272 | |--SEMI -> ; [2165:9]
25273 | |--EXPR -> EXPR [2166:19]
25274 | | `--METHOD_CALL -> ( [2166:19]
25275 | | |--IDENT -> verifyWarns [2166:8]
25276 | | |--ELIST -> ELIST [2166:20]
25277 | | | |--EXPR -> EXPR [2166:20]
25278 | | | | `--IDENT -> checkConfig [2166:20]
25279 | | | |--COMMA -> , [2166:31]
25280 | | | |--EXPR -> EXPR [2166:40]
25281 | | | | `--METHOD_CALL -> ( [2166:40]
25282 | | | | |--IDENT -> getPath [2166:33]
25283 | | | | |--ELIST -> ELIST [2166:41]
25284 | | | | | `--EXPR -> EXPR [2166:41]
25285 | | | | | `--STRING_LITERAL -> "InputIndentationAnonymousClassInMethod.java" [2166:41]
25286 | | | | `--RPAREN -> ) [2166:86]
25287 | | | |--COMMA -> , [2166:87]
25288 | | | `--EXPR -> EXPR [2166:89]
25289 | | | `--IDENT -> expected [2166:89]
25290 | | `--RPAREN -> ) [2166:97]
25291 | |--SEMI -> ; [2166:98]
25292 | `--RCURLY -> } [2167:4]
25293 |--METHOD_DEF -> METHOD_DEF [2169:4]
25294 | |--MODIFIERS -> MODIFIERS [2169:4]
25295 | | |--ANNOTATION -> ANNOTATION [2169:4]
25296 | | | |--AT -> @ [2169:4]
25297 | | | `--IDENT -> Test [2169:5]
25298 | | `--LITERAL_PUBLIC -> public [2170:4]
25299 | |--TYPE -> TYPE [2170:11]
25300 | | `--LITERAL_VOID -> void [2170:11]
25301 | |--IDENT -> testAnonymousClassInMethodWithCurlyOnNewLine [2170:16]
25302 | |--LPAREN -> ( [2170:60]
25303 | |--PARAMETERS -> PARAMETERS [2170:61]
25304 | |--RPAREN -> ) [2170:61]
25305 | |--LITERAL_THROWS -> throws [2170:63]
25306 | | `--IDENT -> Exception [2170:70]
25307 | `--SLIST -> { [2170:80]
25308 | |--VARIABLE_DEF -> VARIABLE_DEF [2171:8]
25309 | | |--MODIFIERS -> MODIFIERS [2171:8]
25310 | | | `--FINAL -> final [2171:8]
25311 | | |--TYPE -> TYPE [2171:14]
25312 | | | `--IDENT -> DefaultConfiguration [2171:14]
25313 | | |--IDENT -> checkConfig [2171:35]
25314 | | `--ASSIGN -> = [2171:47]
25315 | | `--EXPR -> EXPR [2171:67]
25316 | | `--METHOD_CALL -> ( [2171:67]
25317 | | |--IDENT -> createModuleConfig [2171:49]
25318 | | |--ELIST -> ELIST [2171:84]
25319 | | | `--EXPR -> EXPR [2171:84]
25320 | | | `--DOT -> . [2171:84]
25321 | | | |--IDENT -> IndentationCheck [2171:68]
25322 | | | `--LITERAL_CLASS -> class [2171:85]
25323 | | `--RPAREN -> ) [2171:90]
25324 | |--SEMI -> ; [2171:91]
25325 | |--EXPR -> EXPR [2172:32]
25326 | | `--METHOD_CALL -> ( [2172:32]
25327 | | |--DOT -> . [2172:19]
25328 | | | |--IDENT -> checkConfig [2172:8]
25329 | | | `--IDENT -> addAttribute [2172:20]
25330 | | |--ELIST -> ELIST [2172:33]
25331 | | | |--EXPR -> EXPR [2172:33]
25332 | | | | `--STRING_LITERAL -> "tabWidth" [2172:33]
25333 | | | |--COMMA -> , [2172:43]
25334 | | | `--EXPR -> EXPR [2172:45]
25335 | | | `--STRING_LITERAL -> "4" [2172:45]
25336 | | `--RPAREN -> ) [2172:48]
25337 | |--SEMI -> ; [2172:49]
25338 | |--EXPR -> EXPR [2173:32]
25339 | | `--METHOD_CALL -> ( [2173:32]
25340 | | |--DOT -> . [2173:19]
25341 | | | |--IDENT -> checkConfig [2173:8]
25342 | | | `--IDENT -> addAttribute [2173:20]
25343 | | |--ELIST -> ELIST [2173:33]
25344 | | | |--EXPR -> EXPR [2173:33]
25345 | | | | `--STRING_LITERAL -> "basicOffset" [2173:33]
25346 | | | |--COMMA -> , [2173:46]
25347 | | | `--EXPR -> EXPR [2173:48]
25348 | | | `--STRING_LITERAL -> "4" [2173:48]
25349 | | `--RPAREN -> ) [2173:51]
25350 | |--SEMI -> ; [2173:52]
25351 | |--EXPR -> EXPR [2174:32]
25352 | | `--METHOD_CALL -> ( [2174:32]
25353 | | |--DOT -> . [2174:19]
25354 | | | |--IDENT -> checkConfig [2174:8]
25355 | | | `--IDENT -> addAttribute [2174:20]
25356 | | |--ELIST -> ELIST [2174:33]
25357 | | | |--EXPR -> EXPR [2174:33]
25358 | | | | `--STRING_LITERAL -> "braceAdjustment" [2174:33]
25359 | | | |--COMMA -> , [2174:50]
25360 | | | `--EXPR -> EXPR [2174:52]
25361 | | | `--STRING_LITERAL -> "0" [2174:52]
25362 | | `--RPAREN -> ) [2174:55]
25363 | |--SEMI -> ; [2174:56]
25364 | |--EXPR -> EXPR [2175:32]
25365 | | `--METHOD_CALL -> ( [2175:32]
25366 | | |--DOT -> . [2175:19]
25367 | | | |--IDENT -> checkConfig [2175:8]
25368 | | | `--IDENT -> addAttribute [2175:20]
25369 | | |--ELIST -> ELIST [2175:33]
25370 | | | |--EXPR -> EXPR [2175:33]
25371 | | | | `--STRING_LITERAL -> "caseIndent" [2175:33]
25372 | | | |--COMMA -> , [2175:45]
25373 | | | `--EXPR -> EXPR [2175:47]
25374 | | | `--STRING_LITERAL -> "4" [2175:47]
25375 | | `--RPAREN -> ) [2175:50]
25376 | |--SEMI -> ; [2175:51]
25377 | |--EXPR -> EXPR [2176:32]
25378 | | `--METHOD_CALL -> ( [2176:32]
25379 | | |--DOT -> . [2176:19]
25380 | | | |--IDENT -> checkConfig [2176:8]
25381 | | | `--IDENT -> addAttribute [2176:20]
25382 | | |--ELIST -> ELIST [2176:33]
25383 | | | |--EXPR -> EXPR [2176:33]
25384 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2176:33]
25385 | | | |--COMMA -> , [2176:58]
25386 | | | `--EXPR -> EXPR [2176:60]
25387 | | | `--STRING_LITERAL -> "8" [2176:60]
25388 | | `--RPAREN -> ) [2176:63]
25389 | |--SEMI -> ; [2176:64]
25390 | |--EXPR -> EXPR [2177:32]
25391 | | `--METHOD_CALL -> ( [2177:32]
25392 | | |--DOT -> . [2177:19]
25393 | | | |--IDENT -> checkConfig [2177:8]
25394 | | | `--IDENT -> addAttribute [2177:20]
25395 | | |--ELIST -> ELIST [2177:33]
25396 | | | |--EXPR -> EXPR [2177:33]
25397 | | | | `--STRING_LITERAL -> "throwsIndent" [2177:33]
25398 | | | |--COMMA -> , [2177:47]
25399 | | | `--EXPR -> EXPR [2177:49]
25400 | | | `--STRING_LITERAL -> "4" [2177:49]
25401 | | `--RPAREN -> ) [2177:52]
25402 | |--SEMI -> ; [2177:53]
25403 | |--EXPR -> EXPR [2178:32]
25404 | | `--METHOD_CALL -> ( [2178:32]
25405 | | |--DOT -> . [2178:19]
25406 | | | |--IDENT -> checkConfig [2178:8]
25407 | | | `--IDENT -> addAttribute [2178:20]
25408 | | |--ELIST -> ELIST [2178:33]
25409 | | | |--EXPR -> EXPR [2178:33]
25410 | | | | `--STRING_LITERAL -> "arrayInitIndent" [2178:33]
25411 | | | |--COMMA -> , [2178:50]
25412 | | | `--EXPR -> EXPR [2178:52]
25413 | | | `--STRING_LITERAL -> "4" [2178:52]
25414 | | `--RPAREN -> ) [2178:55]
25415 | |--SEMI -> ; [2178:56]
25416 | |--VARIABLE_DEF -> VARIABLE_DEF [2179:8]
25417 | | |--MODIFIERS -> MODIFIERS [2179:8]
25418 | | | `--FINAL -> final [2179:8]
25419 | | |--TYPE -> TYPE [2179:20]
25420 | | | `--ARRAY_DECLARATOR -> [ [2179:20]
25421 | | | |--IDENT -> String [2179:14]
25422 | | | `--RBRACK -> ] [2179:21]
25423 | | |--IDENT -> expected [2179:23]
25424 | | `--ASSIGN -> = [2179:32]
25425 | | `--ARRAY_INIT -> { [2179:34]
25426 | | |--EXPR -> EXPR [2180:22]
25427 | | | `--PLUS -> + [2180:22]
25428 | | | |--STRING_LITERAL -> "40:19: " [2180:12]
25429 | | | `--METHOD_CALL -> ( [2180:39]
25430 | | | |--IDENT -> getCheckMessage [2180:24]
25431 | | | |--ELIST -> ELIST [2180:40]
25432 | | | | |--EXPR -> EXPR [2180:40]
25433 | | | | | `--IDENT -> MSG_ERROR_MULTI [2180:40]
25434 | | | | |--COMMA -> , [2180:55]
25435 | | | | |--EXPR -> EXPR [2180:57]
25436 | | | | | `--STRING_LITERAL -> "object def rcurly" [2180:57]
25437 | | | | |--COMMA -> , [2180:76]
25438 | | | | |--EXPR -> EXPR [2180:78]
25439 | | | | | `--NUM_INT -> 18 [2180:78]
25440 | | | | |--COMMA -> , [2180:80]
25441 | | | | `--EXPR -> EXPR [2180:82]
25442 | | | | `--STRING_LITERAL -> "16, 20, 24" [2180:82]
25443 | | | `--RPAREN -> ) [2180:94]
25444 | | |--COMMA -> , [2180:95]
25445 | | |--EXPR -> EXPR [2181:22]
25446 | | | `--PLUS -> + [2181:22]
25447 | | | |--STRING_LITERAL -> "42:15: " [2181:12]
25448 | | | `--METHOD_CALL -> ( [2181:39]
25449 | | | |--IDENT -> getCheckMessage [2181:24]
25450 | | | |--ELIST -> ELIST [2181:40]
25451 | | | | |--EXPR -> EXPR [2181:40]
25452 | | | | | `--IDENT -> MSG_ERROR [2181:40]
25453 | | | | |--COMMA -> , [2181:49]
25454 | | | | |--EXPR -> EXPR [2181:51]
25455 | | | | | `--STRING_LITERAL -> "new" [2181:51]
25456 | | | | |--COMMA -> , [2181:56]
25457 | | | | |--EXPR -> EXPR [2181:58]
25458 | | | | | `--NUM_INT -> 14 [2181:58]
25459 | | | | |--COMMA -> , [2181:60]
25460 | | | | `--EXPR -> EXPR [2181:62]
25461 | | | | `--NUM_INT -> 16 [2181:62]
25462 | | | `--RPAREN -> ) [2181:64]
25463 | | |--COMMA -> , [2181:65]
25464 | | |--EXPR -> EXPR [2182:22]
25465 | | | `--PLUS -> + [2182:22]
25466 | | | |--STRING_LITERAL -> "48:15: " [2182:12]
25467 | | | `--METHOD_CALL -> ( [2182:39]
25468 | | | |--IDENT -> getCheckMessage [2182:24]
25469 | | | |--ELIST -> ELIST [2182:40]
25470 | | | | |--EXPR -> EXPR [2182:40]
25471 | | | | | `--IDENT -> MSG_ERROR_MULTI [2182:40]
25472 | | | | |--COMMA -> , [2182:55]
25473 | | | | |--EXPR -> EXPR [2182:57]
25474 | | | | | `--STRING_LITERAL -> "object def rcurly" [2182:57]
25475 | | | | |--COMMA -> , [2182:76]
25476 | | | | |--EXPR -> EXPR [2182:78]
25477 | | | | | `--NUM_INT -> 14 [2182:78]
25478 | | | | |--COMMA -> , [2182:80]
25479 | | | | `--EXPR -> EXPR [2182:82]
25480 | | | | `--STRING_LITERAL -> "16, 20, 24" [2182:82]
25481 | | | `--RPAREN -> ) [2182:94]
25482 | | |--COMMA -> , [2182:95]
25483 | | |--EXPR -> EXPR [2183:22]
25484 | | | `--PLUS -> + [2183:22]
25485 | | | |--STRING_LITERAL -> "60:19: " [2183:12]
25486 | | | `--METHOD_CALL -> ( [2183:39]
25487 | | | |--IDENT -> getCheckMessage [2183:24]
25488 | | | |--ELIST -> ELIST [2183:40]
25489 | | | | |--EXPR -> EXPR [2183:40]
25490 | | | | | `--IDENT -> MSG_ERROR_MULTI [2183:40]
25491 | | | | |--COMMA -> , [2183:55]
25492 | | | | |--EXPR -> EXPR [2183:57]
25493 | | | | | `--STRING_LITERAL -> "object def lcurly" [2183:57]
25494 | | | | |--COMMA -> , [2183:76]
25495 | | | | |--EXPR -> EXPR [2183:78]
25496 | | | | | `--NUM_INT -> 18 [2183:78]
25497 | | | | |--COMMA -> , [2183:80]
25498 | | | | `--EXPR -> EXPR [2183:82]
25499 | | | | `--STRING_LITERAL -> "16, 20, 24" [2183:82]
25500 | | | `--RPAREN -> ) [2183:94]
25501 | | |--COMMA -> , [2183:95]
25502 | | |--EXPR -> EXPR [2184:22]
25503 | | | `--PLUS -> + [2184:22]
25504 | | | |--STRING_LITERAL -> "66:19: " [2184:12]
25505 | | | `--METHOD_CALL -> ( [2184:39]
25506 | | | |--IDENT -> getCheckMessage [2184:24]
25507 | | | |--ELIST -> ELIST [2184:40]
25508 | | | | |--EXPR -> EXPR [2184:40]
25509 | | | | | `--IDENT -> MSG_ERROR_MULTI [2184:40]
25510 | | | | |--COMMA -> , [2184:55]
25511 | | | | |--EXPR -> EXPR [2184:57]
25512 | | | | | `--STRING_LITERAL -> "object def rcurly" [2184:57]
25513 | | | | |--COMMA -> , [2184:76]
25514 | | | | |--EXPR -> EXPR [2184:78]
25515 | | | | | `--NUM_INT -> 18 [2184:78]
25516 | | | | |--COMMA -> , [2184:80]
25517 | | | | `--EXPR -> EXPR [2184:82]
25518 | | | | `--STRING_LITERAL -> "16, 20, 24" [2184:82]
25519 | | | `--RPAREN -> ) [2184:94]
25520 | | |--COMMA -> , [2184:95]
25521 | | |--EXPR -> EXPR [2185:22]
25522 | | | `--PLUS -> + [2185:22]
25523 | | | |--STRING_LITERAL -> "69:15: " [2185:12]
25524 | | | `--METHOD_CALL -> ( [2185:39]
25525 | | | |--IDENT -> getCheckMessage [2185:24]
25526 | | | |--ELIST -> ELIST [2185:40]
25527 | | | | |--EXPR -> EXPR [2185:40]
25528 | | | | | `--IDENT -> MSG_ERROR_MULTI [2185:40]
25529 | | | | |--COMMA -> , [2185:55]
25530 | | | | |--EXPR -> EXPR [2185:57]
25531 | | | | | `--STRING_LITERAL -> "object def lcurly" [2185:57]
25532 | | | | |--COMMA -> , [2185:76]
25533 | | | | |--EXPR -> EXPR [2185:78]
25534 | | | | | `--NUM_INT -> 14 [2185:78]
25535 | | | | |--COMMA -> , [2185:80]
25536 | | | | `--EXPR -> EXPR [2185:82]
25537 | | | | `--STRING_LITERAL -> "16, 20, 24" [2185:82]
25538 | | | `--RPAREN -> ) [2185:94]
25539 | | |--COMMA -> , [2185:95]
25540 | | |--EXPR -> EXPR [2186:22]
25541 | | | `--PLUS -> + [2186:22]
25542 | | | |--STRING_LITERAL -> "75:15: " [2186:12]
25543 | | | `--METHOD_CALL -> ( [2186:39]
25544 | | | |--IDENT -> getCheckMessage [2186:24]
25545 | | | |--ELIST -> ELIST [2186:40]
25546 | | | | |--EXPR -> EXPR [2186:40]
25547 | | | | | `--IDENT -> MSG_ERROR_MULTI [2186:40]
25548 | | | | |--COMMA -> , [2186:55]
25549 | | | | |--EXPR -> EXPR [2186:57]
25550 | | | | | `--STRING_LITERAL -> "object def rcurly" [2186:57]
25551 | | | | |--COMMA -> , [2186:76]
25552 | | | | |--EXPR -> EXPR [2186:78]
25553 | | | | | `--NUM_INT -> 14 [2186:78]
25554 | | | | |--COMMA -> , [2186:80]
25555 | | | | `--EXPR -> EXPR [2186:82]
25556 | | | | `--STRING_LITERAL -> "16, 20, 24" [2186:82]
25557 | | | `--RPAREN -> ) [2186:94]
25558 | | |--COMMA -> , [2186:95]
25559 | | `--RCURLY -> } [2187:8]
25560 | |--SEMI -> ; [2187:9]
25561 | |--EXPR -> EXPR [2188:19]
25562 | | `--METHOD_CALL -> ( [2188:19]
25563 | | |--IDENT -> verifyWarns [2188:8]
25564 | | |--ELIST -> ELIST [2188:20]
25565 | | | |--EXPR -> EXPR [2188:20]
25566 | | | | `--IDENT -> checkConfig [2188:20]
25567 | | | |--COMMA -> , [2188:31]
25568 | | | |--EXPR -> EXPR [2189:19]
25569 | | | | `--METHOD_CALL -> ( [2189:19]
25570 | | | | |--IDENT -> getPath [2189:12]
25571 | | | | |--ELIST -> ELIST [2189:20]
25572 | | | | | `--EXPR -> EXPR [2189:20]
25573 | | | | | `--STRING_LITERAL -> "InputIndentationAnonymousClassInMethodCurlyOnNewLine.java" [2189:20]
25574 | | | | `--RPAREN -> ) [2189:79]
25575 | | | |--COMMA -> , [2189:80]
25576 | | | `--EXPR -> EXPR [2189:82]
25577 | | | `--IDENT -> expected [2189:82]
25578 | | `--RPAREN -> ) [2189:90]
25579 | |--SEMI -> ; [2189:91]
25580 | `--RCURLY -> } [2190:4]
25581 |--METHOD_DEF -> METHOD_DEF [2192:4]
25582 | |--MODIFIERS -> MODIFIERS [2192:4]
25583 | | |--ANNOTATION -> ANNOTATION [2192:4]
25584 | | | |--AT -> @ [2192:4]
25585 | | | `--IDENT -> Test [2192:5]
25586 | | `--LITERAL_PUBLIC -> public [2193:4]
25587 | |--TYPE -> TYPE [2193:11]
25588 | | `--LITERAL_VOID -> void [2193:11]
25589 | |--IDENT -> testAnnotationDefinition [2193:16]
25590 | |--LPAREN -> ( [2193:40]
25591 | |--PARAMETERS -> PARAMETERS [2193:41]
25592 | |--RPAREN -> ) [2193:41]
25593 | |--LITERAL_THROWS -> throws [2193:43]
25594 | | `--IDENT -> Exception [2193:50]
25595 | `--SLIST -> { [2193:60]
25596 | |--VARIABLE_DEF -> VARIABLE_DEF [2194:8]
25597 | | |--MODIFIERS -> MODIFIERS [2194:8]
25598 | | | `--FINAL -> final [2194:8]
25599 | | |--TYPE -> TYPE [2194:14]
25600 | | | `--IDENT -> DefaultConfiguration [2194:14]
25601 | | |--IDENT -> checkConfig [2194:35]
25602 | | `--ASSIGN -> = [2194:47]
25603 | | `--EXPR -> EXPR [2194:67]
25604 | | `--METHOD_CALL -> ( [2194:67]
25605 | | |--IDENT -> createModuleConfig [2194:49]
25606 | | |--ELIST -> ELIST [2194:84]
25607 | | | `--EXPR -> EXPR [2194:84]
25608 | | | `--DOT -> . [2194:84]
25609 | | | |--IDENT -> IndentationCheck [2194:68]
25610 | | | `--LITERAL_CLASS -> class [2194:85]
25611 | | `--RPAREN -> ) [2194:90]
25612 | |--SEMI -> ; [2194:91]
25613 | |--EXPR -> EXPR [2195:32]
25614 | | `--METHOD_CALL -> ( [2195:32]
25615 | | |--DOT -> . [2195:19]
25616 | | | |--IDENT -> checkConfig [2195:8]
25617 | | | `--IDENT -> addAttribute [2195:20]
25618 | | |--ELIST -> ELIST [2195:33]
25619 | | | |--EXPR -> EXPR [2195:33]
25620 | | | | `--STRING_LITERAL -> "tabWidth" [2195:33]
25621 | | | |--COMMA -> , [2195:43]
25622 | | | `--EXPR -> EXPR [2195:45]
25623 | | | `--STRING_LITERAL -> "4" [2195:45]
25624 | | `--RPAREN -> ) [2195:48]
25625 | |--SEMI -> ; [2195:49]
25626 | |--VARIABLE_DEF -> VARIABLE_DEF [2196:8]
25627 | | |--MODIFIERS -> MODIFIERS [2196:8]
25628 | | | `--FINAL -> final [2196:8]
25629 | | |--TYPE -> TYPE [2196:20]
25630 | | | `--ARRAY_DECLARATOR -> [ [2196:20]
25631 | | | |--IDENT -> String [2196:14]
25632 | | | `--RBRACK -> ] [2196:21]
25633 | | |--IDENT -> expected [2196:23]
25634 | | `--ASSIGN -> = [2196:32]
25635 | | `--EXPR -> EXPR [2196:44]
25636 | | `--DOT -> . [2196:44]
25637 | | |--IDENT -> CommonUtil [2196:34]
25638 | | `--IDENT -> EMPTY_STRING_ARRAY [2196:45]
25639 | |--SEMI -> ; [2196:63]
25640 | |--EXPR -> EXPR [2197:19]
25641 | | `--METHOD_CALL -> ( [2197:19]
25642 | | |--IDENT -> verifyWarns [2197:8]
25643 | | |--ELIST -> ELIST [2197:20]
25644 | | | |--EXPR -> EXPR [2197:20]
25645 | | | | `--IDENT -> checkConfig [2197:20]
25646 | | | |--COMMA -> , [2197:31]
25647 | | | |--EXPR -> EXPR [2197:40]
25648 | | | | `--METHOD_CALL -> ( [2197:40]
25649 | | | | |--IDENT -> getPath [2197:33]
25650 | | | | |--ELIST -> ELIST [2197:41]
25651 | | | | | `--EXPR -> EXPR [2197:41]
25652 | | | | | `--STRING_LITERAL -> "InputIndentationAnnotationDefinition.java" [2197:41]
25653 | | | | `--RPAREN -> ) [2197:84]
25654 | | | |--COMMA -> , [2197:85]
25655 | | | `--EXPR -> EXPR [2197:87]
25656 | | | `--IDENT -> expected [2197:87]
25657 | | `--RPAREN -> ) [2197:95]
25658 | |--SEMI -> ; [2197:96]
25659 | `--RCURLY -> } [2198:4]
25660 |--METHOD_DEF -> METHOD_DEF [2200:4]
25661 | |--MODIFIERS -> MODIFIERS [2200:4]
25662 | | |--ANNOTATION -> ANNOTATION [2200:4]
25663 | | | |--AT -> @ [2200:4]
25664 | | | `--IDENT -> Test [2200:5]
25665 | | `--LITERAL_PUBLIC -> public [2201:4]
25666 | |--TYPE -> TYPE [2201:11]
25667 | | `--LITERAL_VOID -> void [2201:11]
25668 | |--IDENT -> testPackageDeclaration [2201:16]
25669 | |--LPAREN -> ( [2201:38]
25670 | |--PARAMETERS -> PARAMETERS [2201:39]
25671 | |--RPAREN -> ) [2201:39]
25672 | |--LITERAL_THROWS -> throws [2201:41]
25673 | | `--IDENT -> Exception [2201:48]
25674 | `--SLIST -> { [2201:58]
25675 | |--VARIABLE_DEF -> VARIABLE_DEF [2202:8]
25676 | | |--MODIFIERS -> MODIFIERS [2202:8]
25677 | | | `--FINAL -> final [2202:8]
25678 | | |--TYPE -> TYPE [2202:14]
25679 | | | `--IDENT -> DefaultConfiguration [2202:14]
25680 | | |--IDENT -> checkConfig [2202:35]
25681 | | `--ASSIGN -> = [2202:47]
25682 | | `--EXPR -> EXPR [2202:67]
25683 | | `--METHOD_CALL -> ( [2202:67]
25684 | | |--IDENT -> createModuleConfig [2202:49]
25685 | | |--ELIST -> ELIST [2202:84]
25686 | | | `--EXPR -> EXPR [2202:84]
25687 | | | `--DOT -> . [2202:84]
25688 | | | |--IDENT -> IndentationCheck [2202:68]
25689 | | | `--LITERAL_CLASS -> class [2202:85]
25690 | | `--RPAREN -> ) [2202:90]
25691 | |--SEMI -> ; [2202:91]
25692 | |--EXPR -> EXPR [2203:32]
25693 | | `--METHOD_CALL -> ( [2203:32]
25694 | | |--DOT -> . [2203:19]
25695 | | | |--IDENT -> checkConfig [2203:8]
25696 | | | `--IDENT -> addAttribute [2203:20]
25697 | | |--ELIST -> ELIST [2203:33]
25698 | | | |--EXPR -> EXPR [2203:33]
25699 | | | | `--STRING_LITERAL -> "tabWidth" [2203:33]
25700 | | | |--COMMA -> , [2203:43]
25701 | | | `--EXPR -> EXPR [2203:45]
25702 | | | `--STRING_LITERAL -> "4" [2203:45]
25703 | | `--RPAREN -> ) [2203:48]
25704 | |--SEMI -> ; [2203:49]
25705 | |--VARIABLE_DEF -> VARIABLE_DEF [2204:8]
25706 | | |--MODIFIERS -> MODIFIERS [2204:8]
25707 | | | `--FINAL -> final [2204:8]
25708 | | |--TYPE -> TYPE [2204:20]
25709 | | | `--ARRAY_DECLARATOR -> [ [2204:20]
25710 | | | |--IDENT -> String [2204:14]
25711 | | | `--RBRACK -> ] [2204:21]
25712 | | |--IDENT -> expected [2204:23]
25713 | | `--ASSIGN -> = [2204:32]
25714 | | `--ARRAY_INIT -> { [2204:34]
25715 | | |--EXPR -> EXPR [2205:20]
25716 | | | `--PLUS -> + [2205:20]
25717 | | | |--STRING_LITERAL -> "1:2: " [2205:12]
25718 | | | `--METHOD_CALL -> ( [2205:37]
25719 | | | |--IDENT -> getCheckMessage [2205:22]
25720 | | | |--ELIST -> ELIST [2205:38]
25721 | | | | |--EXPR -> EXPR [2205:38]
25722 | | | | | `--IDENT -> MSG_ERROR [2205:38]
25723 | | | | |--COMMA -> , [2205:47]
25724 | | | | |--EXPR -> EXPR [2205:49]
25725 | | | | | `--STRING_LITERAL -> "package def" [2205:49]
25726 | | | | |--COMMA -> , [2205:62]
25727 | | | | |--EXPR -> EXPR [2205:64]
25728 | | | | | `--NUM_INT -> 1 [2205:64]
25729 | | | | |--COMMA -> , [2205:65]
25730 | | | | `--EXPR -> EXPR [2205:67]
25731 | | | | `--NUM_INT -> 0 [2205:67]
25732 | | | `--RPAREN -> ) [2205:68]
25733 | | |--COMMA -> , [2205:69]
25734 | | `--RCURLY -> } [2206:8]
25735 | |--SEMI -> ; [2206:9]
25736 | |--EXPR -> EXPR [2207:19]
25737 | | `--METHOD_CALL -> ( [2207:19]
25738 | | |--IDENT -> verifyWarns [2207:8]
25739 | | |--ELIST -> ELIST [2207:20]
25740 | | | |--EXPR -> EXPR [2207:20]
25741 | | | | `--IDENT -> checkConfig [2207:20]
25742 | | | |--COMMA -> , [2207:31]
25743 | | | |--EXPR -> EXPR [2207:40]
25744 | | | | `--METHOD_CALL -> ( [2207:40]
25745 | | | | |--IDENT -> getPath [2207:33]
25746 | | | | |--ELIST -> ELIST [2207:41]
25747 | | | | | `--EXPR -> EXPR [2207:41]
25748 | | | | | `--STRING_LITERAL -> "InputIndentationPackageDeclaration.java" [2207:41]
25749 | | | | `--RPAREN -> ) [2207:82]
25750 | | | |--COMMA -> , [2207:83]
25751 | | | `--EXPR -> EXPR [2207:85]
25752 | | | `--IDENT -> expected [2207:85]
25753 | | `--RPAREN -> ) [2207:93]
25754 | |--SEMI -> ; [2207:94]
25755 | `--RCURLY -> } [2208:4]
25756 |--METHOD_DEF -> METHOD_DEF [2210:4]
25757 | |--MODIFIERS -> MODIFIERS [2210:4]
25758 | | |--ANNOTATION -> ANNOTATION [2210:4]
25759 | | | |--AT -> @ [2210:4]
25760 | | | `--IDENT -> Test [2210:5]
25761 | | `--LITERAL_PUBLIC -> public [2211:4]
25762 | |--TYPE -> TYPE [2211:11]
25763 | | `--LITERAL_VOID -> void [2211:11]
25764 | |--IDENT -> testPackageDeclaration2 [2211:16]
25765 | |--LPAREN -> ( [2211:39]
25766 | |--PARAMETERS -> PARAMETERS [2211:40]
25767 | |--RPAREN -> ) [2211:40]
25768 | |--LITERAL_THROWS -> throws [2211:42]
25769 | | `--IDENT -> Exception [2211:49]
25770 | `--SLIST -> { [2211:59]
25771 | |--VARIABLE_DEF -> VARIABLE_DEF [2212:8]
25772 | | |--MODIFIERS -> MODIFIERS [2212:8]
25773 | | | `--FINAL -> final [2212:8]
25774 | | |--TYPE -> TYPE [2212:14]
25775 | | | `--IDENT -> DefaultConfiguration [2212:14]
25776 | | |--IDENT -> checkConfig [2212:35]
25777 | | `--ASSIGN -> = [2212:47]
25778 | | `--EXPR -> EXPR [2212:67]
25779 | | `--METHOD_CALL -> ( [2212:67]
25780 | | |--IDENT -> createModuleConfig [2212:49]
25781 | | |--ELIST -> ELIST [2212:84]
25782 | | | `--EXPR -> EXPR [2212:84]
25783 | | | `--DOT -> . [2212:84]
25784 | | | |--IDENT -> IndentationCheck [2212:68]
25785 | | | `--LITERAL_CLASS -> class [2212:85]
25786 | | `--RPAREN -> ) [2212:90]
25787 | |--SEMI -> ; [2212:91]
25788 | |--EXPR -> EXPR [2213:32]
25789 | | `--METHOD_CALL -> ( [2213:32]
25790 | | |--DOT -> . [2213:19]
25791 | | | |--IDENT -> checkConfig [2213:8]
25792 | | | `--IDENT -> addAttribute [2213:20]
25793 | | |--ELIST -> ELIST [2213:33]
25794 | | | |--EXPR -> EXPR [2213:33]
25795 | | | | `--STRING_LITERAL -> "tabWidth" [2213:33]
25796 | | | |--COMMA -> , [2213:43]
25797 | | | `--EXPR -> EXPR [2213:45]
25798 | | | `--STRING_LITERAL -> "4" [2213:45]
25799 | | `--RPAREN -> ) [2213:48]
25800 | |--SEMI -> ; [2213:49]
25801 | |--VARIABLE_DEF -> VARIABLE_DEF [2214:8]
25802 | | |--MODIFIERS -> MODIFIERS [2214:8]
25803 | | | `--FINAL -> final [2214:8]
25804 | | |--TYPE -> TYPE [2214:20]
25805 | | | `--ARRAY_DECLARATOR -> [ [2214:20]
25806 | | | |--IDENT -> String [2214:14]
25807 | | | `--RBRACK -> ] [2214:21]
25808 | | |--IDENT -> expected [2214:23]
25809 | | `--ASSIGN -> = [2214:32]
25810 | | `--ARRAY_INIT -> { [2214:34]
25811 | | |--EXPR -> EXPR [2215:20]
25812 | | | `--PLUS -> + [2215:20]
25813 | | | |--STRING_LITERAL -> "2:2: " [2215:12]
25814 | | | `--METHOD_CALL -> ( [2215:37]
25815 | | | |--IDENT -> getCheckMessage [2215:22]
25816 | | | |--ELIST -> ELIST [2215:38]
25817 | | | | |--EXPR -> EXPR [2215:38]
25818 | | | | | `--IDENT -> MSG_ERROR [2215:38]
25819 | | | | |--COMMA -> , [2215:47]
25820 | | | | |--EXPR -> EXPR [2215:49]
25821 | | | | | `--STRING_LITERAL -> "package def" [2215:49]
25822 | | | | |--COMMA -> , [2215:62]
25823 | | | | |--EXPR -> EXPR [2215:64]
25824 | | | | | `--NUM_INT -> 1 [2215:64]
25825 | | | | |--COMMA -> , [2215:65]
25826 | | | | `--EXPR -> EXPR [2215:67]
25827 | | | | `--NUM_INT -> 0 [2215:67]
25828 | | | `--RPAREN -> ) [2215:68]
25829 | | |--COMMA -> , [2215:69]
25830 | | `--RCURLY -> } [2216:8]
25831 | |--SEMI -> ; [2216:9]
25832 | |--EXPR -> EXPR [2217:19]
25833 | | `--METHOD_CALL -> ( [2217:19]
25834 | | |--IDENT -> verifyWarns [2217:8]
25835 | | |--ELIST -> ELIST [2217:20]
25836 | | | |--EXPR -> EXPR [2217:20]
25837 | | | | `--IDENT -> checkConfig [2217:20]
25838 | | | |--COMMA -> , [2217:31]
25839 | | | |--EXPR -> EXPR [2218:19]
25840 | | | | `--METHOD_CALL -> ( [2218:19]
25841 | | | | |--IDENT -> getPath [2218:12]
25842 | | | | |--ELIST -> ELIST [2218:20]
25843 | | | | | `--EXPR -> EXPR [2218:20]
25844 | | | | | `--STRING_LITERAL -> "package-info.java" [2218:20]
25845 | | | | `--RPAREN -> ) [2218:39]
25846 | | | |--COMMA -> , [2218:40]
25847 | | | `--EXPR -> EXPR [2218:42]
25848 | | | `--IDENT -> expected [2218:42]
25849 | | `--RPAREN -> ) [2218:50]
25850 | |--SEMI -> ; [2218:51]
25851 | `--RCURLY -> } [2219:4]
25852 |--METHOD_DEF -> METHOD_DEF [2221:4]
25853 | |--MODIFIERS -> MODIFIERS [2221:4]
25854 | | |--ANNOTATION -> ANNOTATION [2221:4]
25855 | | | |--AT -> @ [2221:4]
25856 | | | `--IDENT -> Test [2221:5]
25857 | | `--LITERAL_PUBLIC -> public [2222:4]
25858 | |--TYPE -> TYPE [2222:11]
25859 | | `--LITERAL_VOID -> void [2222:11]
25860 | |--IDENT -> testPackageDeclaration3 [2222:16]
25861 | |--LPAREN -> ( [2222:39]
25862 | |--PARAMETERS -> PARAMETERS [2222:40]
25863 | |--RPAREN -> ) [2222:40]
25864 | |--LITERAL_THROWS -> throws [2222:42]
25865 | | `--IDENT -> Exception [2222:49]
25866 | `--SLIST -> { [2222:59]
25867 | |--VARIABLE_DEF -> VARIABLE_DEF [2223:8]
25868 | | |--MODIFIERS -> MODIFIERS [2223:8]
25869 | | | `--FINAL -> final [2223:8]
25870 | | |--TYPE -> TYPE [2223:14]
25871 | | | `--IDENT -> DefaultConfiguration [2223:14]
25872 | | |--IDENT -> checkConfig [2223:35]
25873 | | `--ASSIGN -> = [2223:47]
25874 | | `--EXPR -> EXPR [2223:67]
25875 | | `--METHOD_CALL -> ( [2223:67]
25876 | | |--IDENT -> createModuleConfig [2223:49]
25877 | | |--ELIST -> ELIST [2223:84]
25878 | | | `--EXPR -> EXPR [2223:84]
25879 | | | `--DOT -> . [2223:84]
25880 | | | |--IDENT -> IndentationCheck [2223:68]
25881 | | | `--LITERAL_CLASS -> class [2223:85]
25882 | | `--RPAREN -> ) [2223:90]
25883 | |--SEMI -> ; [2223:91]
25884 | |--EXPR -> EXPR [2224:32]
25885 | | `--METHOD_CALL -> ( [2224:32]
25886 | | |--DOT -> . [2224:19]
25887 | | | |--IDENT -> checkConfig [2224:8]
25888 | | | `--IDENT -> addAttribute [2224:20]
25889 | | |--ELIST -> ELIST [2224:33]
25890 | | | |--EXPR -> EXPR [2224:33]
25891 | | | | `--STRING_LITERAL -> "tabWidth" [2224:33]
25892 | | | |--COMMA -> , [2224:43]
25893 | | | `--EXPR -> EXPR [2224:45]
25894 | | | `--STRING_LITERAL -> "4" [2224:45]
25895 | | `--RPAREN -> ) [2224:48]
25896 | |--SEMI -> ; [2224:49]
25897 | |--VARIABLE_DEF -> VARIABLE_DEF [2225:8]
25898 | | |--MODIFIERS -> MODIFIERS [2225:8]
25899 | | | `--FINAL -> final [2225:8]
25900 | | |--TYPE -> TYPE [2225:20]
25901 | | | `--ARRAY_DECLARATOR -> [ [2225:20]
25902 | | | |--IDENT -> String [2225:14]
25903 | | | `--RBRACK -> ] [2225:21]
25904 | | |--IDENT -> expected [2225:23]
25905 | | `--ASSIGN -> = [2225:32]
25906 | | `--EXPR -> EXPR [2225:44]
25907 | | `--DOT -> . [2225:44]
25908 | | |--IDENT -> CommonUtil [2225:34]
25909 | | `--IDENT -> EMPTY_STRING_ARRAY [2225:45]
25910 | |--SEMI -> ; [2225:63]
25911 | |--EXPR -> EXPR [2226:19]
25912 | | `--METHOD_CALL -> ( [2226:19]
25913 | | |--IDENT -> verifyWarns [2226:8]
25914 | | |--ELIST -> ELIST [2226:20]
25915 | | | |--EXPR -> EXPR [2226:20]
25916 | | | | `--IDENT -> checkConfig [2226:20]
25917 | | | |--COMMA -> , [2226:31]
25918 | | | |--EXPR -> EXPR [2226:40]
25919 | | | | `--METHOD_CALL -> ( [2226:40]
25920 | | | | |--IDENT -> getPath [2226:33]
25921 | | | | |--ELIST -> ELIST [2226:41]
25922 | | | | | `--EXPR -> EXPR [2226:41]
25923 | | | | | `--STRING_LITERAL -> "InputIndentationPackageDeclaration3.java" [2226:41]
25924 | | | | `--RPAREN -> ) [2226:83]
25925 | | | |--COMMA -> , [2226:84]
25926 | | | `--EXPR -> EXPR [2226:86]
25927 | | | `--IDENT -> expected [2226:86]
25928 | | `--RPAREN -> ) [2226:94]
25929 | |--SEMI -> ; [2226:95]
25930 | `--RCURLY -> } [2227:4]
25931 |--METHOD_DEF -> METHOD_DEF [2229:4]
25932 | |--MODIFIERS -> MODIFIERS [2229:4]
25933 | | |--ANNOTATION -> ANNOTATION [2229:4]
25934 | | | |--AT -> @ [2229:4]
25935 | | | `--IDENT -> Test [2229:5]
25936 | | `--LITERAL_PUBLIC -> public [2230:4]
25937 | |--TYPE -> TYPE [2230:11]
25938 | | `--LITERAL_VOID -> void [2230:11]
25939 | |--IDENT -> testPackageDeclaration4 [2230:16]
25940 | |--LPAREN -> ( [2230:39]
25941 | |--PARAMETERS -> PARAMETERS [2230:40]
25942 | |--RPAREN -> ) [2230:40]
25943 | |--LITERAL_THROWS -> throws [2230:42]
25944 | | `--IDENT -> Exception [2230:49]
25945 | `--SLIST -> { [2230:59]
25946 | |--VARIABLE_DEF -> VARIABLE_DEF [2231:8]
25947 | | |--MODIFIERS -> MODIFIERS [2231:8]
25948 | | | `--FINAL -> final [2231:8]
25949 | | |--TYPE -> TYPE [2231:14]
25950 | | | `--IDENT -> DefaultConfiguration [2231:14]
25951 | | |--IDENT -> checkConfig [2231:35]
25952 | | `--ASSIGN -> = [2231:47]
25953 | | `--EXPR -> EXPR [2231:67]
25954 | | `--METHOD_CALL -> ( [2231:67]
25955 | | |--IDENT -> createModuleConfig [2231:49]
25956 | | |--ELIST -> ELIST [2231:84]
25957 | | | `--EXPR -> EXPR [2231:84]
25958 | | | `--DOT -> . [2231:84]
25959 | | | |--IDENT -> IndentationCheck [2231:68]
25960 | | | `--LITERAL_CLASS -> class [2231:85]
25961 | | `--RPAREN -> ) [2231:90]
25962 | |--SEMI -> ; [2231:91]
25963 | |--EXPR -> EXPR [2232:32]
25964 | | `--METHOD_CALL -> ( [2232:32]
25965 | | |--DOT -> . [2232:19]
25966 | | | |--IDENT -> checkConfig [2232:8]
25967 | | | `--IDENT -> addAttribute [2232:20]
25968 | | |--ELIST -> ELIST [2232:33]
25969 | | | |--EXPR -> EXPR [2232:33]
25970 | | | | `--STRING_LITERAL -> "tabWidth" [2232:33]
25971 | | | |--COMMA -> , [2232:43]
25972 | | | `--EXPR -> EXPR [2232:45]
25973 | | | `--STRING_LITERAL -> "4" [2232:45]
25974 | | `--RPAREN -> ) [2232:48]
25975 | |--SEMI -> ; [2232:49]
25976 | |--VARIABLE_DEF -> VARIABLE_DEF [2233:8]
25977 | | |--MODIFIERS -> MODIFIERS [2233:8]
25978 | | | `--FINAL -> final [2233:8]
25979 | | |--TYPE -> TYPE [2233:20]
25980 | | | `--ARRAY_DECLARATOR -> [ [2233:20]
25981 | | | |--IDENT -> String [2233:14]
25982 | | | `--RBRACK -> ] [2233:21]
25983 | | |--IDENT -> expected [2233:23]
25984 | | `--ASSIGN -> = [2233:32]
25985 | | `--ARRAY_INIT -> { [2233:34]
25986 | | |--EXPR -> EXPR [2234:20]
25987 | | | `--PLUS -> + [2234:20]
25988 | | | |--STRING_LITERAL -> "2:1: " [2234:12]
25989 | | | `--METHOD_CALL -> ( [2234:37]
25990 | | | |--IDENT -> getCheckMessage [2234:22]
25991 | | | |--ELIST -> ELIST [2234:38]
25992 | | | | |--EXPR -> EXPR [2234:38]
25993 | | | | | `--IDENT -> MSG_ERROR [2234:38]
25994 | | | | |--COMMA -> , [2234:47]
25995 | | | | |--EXPR -> EXPR [2234:49]
25996 | | | | | `--STRING_LITERAL -> "com" [2234:49]
25997 | | | | |--COMMA -> , [2234:54]
25998 | | | | |--EXPR -> EXPR [2234:56]
25999 | | | | | `--NUM_INT -> 0 [2234:56]
26000 | | | | |--COMMA -> , [2234:57]
26001 | | | | `--EXPR -> EXPR [2234:59]
26002 | | | | `--NUM_INT -> 4 [2234:59]
26003 | | | `--RPAREN -> ) [2234:60]
26004 | | |--COMMA -> , [2234:61]
26005 | | |--EXPR -> EXPR [2235:20]
26006 | | | `--PLUS -> + [2235:20]
26007 | | | |--STRING_LITERAL -> "3:1: " [2235:12]
26008 | | | `--METHOD_CALL -> ( [2235:37]
26009 | | | |--IDENT -> getCheckMessage [2235:22]
26010 | | | |--ELIST -> ELIST [2235:38]
26011 | | | | |--EXPR -> EXPR [2235:38]
26012 | | | | | `--IDENT -> MSG_ERROR [2235:38]
26013 | | | | |--COMMA -> , [2235:47]
26014 | | | | |--EXPR -> EXPR [2235:49]
26015 | | | | | `--STRING_LITERAL -> "checks" [2235:49]
26016 | | | | |--COMMA -> , [2235:57]
26017 | | | | |--EXPR -> EXPR [2235:59]
26018 | | | | | `--NUM_INT -> 0 [2235:59]
26019 | | | | |--COMMA -> , [2235:60]
26020 | | | | `--EXPR -> EXPR [2235:62]
26021 | | | | `--NUM_INT -> 4 [2235:62]
26022 | | | `--RPAREN -> ) [2235:63]
26023 | | |--COMMA -> , [2235:64]
26024 | | `--RCURLY -> } [2236:8]
26025 | |--SEMI -> ; [2236:9]
26026 | |--EXPR -> EXPR [2237:19]
26027 | | `--METHOD_CALL -> ( [2237:19]
26028 | | |--IDENT -> verifyWarns [2237:8]
26029 | | |--ELIST -> ELIST [2237:20]
26030 | | | |--EXPR -> EXPR [2237:20]
26031 | | | | `--IDENT -> checkConfig [2237:20]
26032 | | | |--COMMA -> , [2237:31]
26033 | | | |--EXPR -> EXPR [2237:40]
26034 | | | | `--METHOD_CALL -> ( [2237:40]
26035 | | | | |--IDENT -> getPath [2237:33]
26036 | | | | |--ELIST -> ELIST [2237:41]
26037 | | | | | `--EXPR -> EXPR [2237:41]
26038 | | | | | `--STRING_LITERAL -> "InputIndentationPackageDeclaration4.java" [2237:41]
26039 | | | | `--RPAREN -> ) [2237:83]
26040 | | | |--COMMA -> , [2237:84]
26041 | | | `--EXPR -> EXPR [2237:86]
26042 | | | `--IDENT -> expected [2237:86]
26043 | | `--RPAREN -> ) [2237:94]
26044 | |--SEMI -> ; [2237:95]
26045 | `--RCURLY -> } [2238:4]
26046 |--METHOD_DEF -> METHOD_DEF [2240:4]
26047 | |--MODIFIERS -> MODIFIERS [2240:4]
26048 | | |--ANNOTATION -> ANNOTATION [2240:4]
26049 | | | |--AT -> @ [2240:4]
26050 | | | `--IDENT -> Test [2240:5]
26051 | | `--LITERAL_PUBLIC -> public [2241:4]
26052 | |--TYPE -> TYPE [2241:11]
26053 | | `--LITERAL_VOID -> void [2241:11]
26054 | |--IDENT -> testLambda1 [2241:16]
26055 | |--LPAREN -> ( [2241:27]
26056 | |--PARAMETERS -> PARAMETERS [2241:28]
26057 | |--RPAREN -> ) [2241:28]
26058 | |--LITERAL_THROWS -> throws [2241:30]
26059 | | `--IDENT -> Exception [2241:37]
26060 | `--SLIST -> { [2241:47]
26061 | |--VARIABLE_DEF -> VARIABLE_DEF [2242:8]
26062 | | |--MODIFIERS -> MODIFIERS [2242:8]
26063 | | | `--FINAL -> final [2242:8]
26064 | | |--TYPE -> TYPE [2242:14]
26065 | | | `--IDENT -> DefaultConfiguration [2242:14]
26066 | | |--IDENT -> checkConfig [2242:35]
26067 | | `--ASSIGN -> = [2242:47]
26068 | | `--EXPR -> EXPR [2242:67]
26069 | | `--METHOD_CALL -> ( [2242:67]
26070 | | |--IDENT -> createModuleConfig [2242:49]
26071 | | |--ELIST -> ELIST [2242:84]
26072 | | | `--EXPR -> EXPR [2242:84]
26073 | | | `--DOT -> . [2242:84]
26074 | | | |--IDENT -> IndentationCheck [2242:68]
26075 | | | `--LITERAL_CLASS -> class [2242:85]
26076 | | `--RPAREN -> ) [2242:90]
26077 | |--SEMI -> ; [2242:91]
26078 | |--EXPR -> EXPR [2243:32]
26079 | | `--METHOD_CALL -> ( [2243:32]
26080 | | |--DOT -> . [2243:19]
26081 | | | |--IDENT -> checkConfig [2243:8]
26082 | | | `--IDENT -> addAttribute [2243:20]
26083 | | |--ELIST -> ELIST [2243:33]
26084 | | | |--EXPR -> EXPR [2243:33]
26085 | | | | `--STRING_LITERAL -> "tabWidth" [2243:33]
26086 | | | |--COMMA -> , [2243:43]
26087 | | | `--EXPR -> EXPR [2243:45]
26088 | | | `--STRING_LITERAL -> "2" [2243:45]
26089 | | `--RPAREN -> ) [2243:48]
26090 | |--SEMI -> ; [2243:49]
26091 | |--EXPR -> EXPR [2244:32]
26092 | | `--METHOD_CALL -> ( [2244:32]
26093 | | |--DOT -> . [2244:19]
26094 | | | |--IDENT -> checkConfig [2244:8]
26095 | | | `--IDENT -> addAttribute [2244:20]
26096 | | |--ELIST -> ELIST [2244:33]
26097 | | | |--EXPR -> EXPR [2244:33]
26098 | | | | `--STRING_LITERAL -> "basicOffset" [2244:33]
26099 | | | |--COMMA -> , [2244:46]
26100 | | | `--EXPR -> EXPR [2244:48]
26101 | | | `--STRING_LITERAL -> "2" [2244:48]
26102 | | `--RPAREN -> ) [2244:51]
26103 | |--SEMI -> ; [2244:52]
26104 | |--EXPR -> EXPR [2245:32]
26105 | | `--METHOD_CALL -> ( [2245:32]
26106 | | |--DOT -> . [2245:19]
26107 | | | |--IDENT -> checkConfig [2245:8]
26108 | | | `--IDENT -> addAttribute [2245:20]
26109 | | |--ELIST -> ELIST [2245:33]
26110 | | | |--EXPR -> EXPR [2245:33]
26111 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2245:33]
26112 | | | |--COMMA -> , [2245:58]
26113 | | | `--EXPR -> EXPR [2245:60]
26114 | | | `--STRING_LITERAL -> "4" [2245:60]
26115 | | `--RPAREN -> ) [2245:63]
26116 | |--SEMI -> ; [2245:64]
26117 | |--VARIABLE_DEF -> VARIABLE_DEF [2246:8]
26118 | | |--MODIFIERS -> MODIFIERS [2246:8]
26119 | | | `--FINAL -> final [2246:8]
26120 | | |--TYPE -> TYPE [2246:20]
26121 | | | `--ARRAY_DECLARATOR -> [ [2246:20]
26122 | | | |--IDENT -> String [2246:14]
26123 | | | `--RBRACK -> ] [2246:21]
26124 | | |--IDENT -> expected [2246:23]
26125 | | `--ASSIGN -> = [2246:32]
26126 | | `--ARRAY_INIT -> { [2246:34]
26127 | | |--EXPR -> EXPR [2247:21]
26128 | | | `--PLUS -> + [2247:21]
26129 | | | |--STRING_LITERAL -> "46:6: " [2247:12]
26130 | | | `--METHOD_CALL -> ( [2247:38]
26131 | | | |--IDENT -> getCheckMessage [2247:23]
26132 | | | |--ELIST -> ELIST [2247:39]
26133 | | | | |--EXPR -> EXPR [2247:39]
26134 | | | | | `--IDENT -> MSG_ERROR_MULTI [2247:39]
26135 | | | | |--COMMA -> , [2247:54]
26136 | | | | |--EXPR -> EXPR [2247:56]
26137 | | | | | `--STRING_LITERAL -> "block lcurly" [2247:56]
26138 | | | | |--COMMA -> , [2247:70]
26139 | | | | |--EXPR -> EXPR [2247:72]
26140 | | | | | `--NUM_INT -> 5 [2247:72]
26141 | | | | |--COMMA -> , [2247:73]
26142 | | | | `--EXPR -> EXPR [2247:75]
26143 | | | | `--STRING_LITERAL -> "4, 8" [2247:75]
26144 | | | `--RPAREN -> ) [2247:81]
26145 | | |--COMMA -> , [2247:82]
26146 | | |--EXPR -> EXPR [2248:21]
26147 | | | `--PLUS -> + [2248:21]
26148 | | | |--STRING_LITERAL -> "47:6: " [2248:12]
26149 | | | `--METHOD_CALL -> ( [2248:38]
26150 | | | |--IDENT -> getCheckMessage [2248:23]
26151 | | | |--ELIST -> ELIST [2248:39]
26152 | | | | |--EXPR -> EXPR [2248:39]
26153 | | | | | `--IDENT -> MSG_ERROR_MULTI [2248:39]
26154 | | | | |--COMMA -> , [2248:54]
26155 | | | | |--EXPR -> EXPR [2248:56]
26156 | | | | | `--STRING_LITERAL -> "block rcurly" [2248:56]
26157 | | | | |--COMMA -> , [2248:70]
26158 | | | | |--EXPR -> EXPR [2248:72]
26159 | | | | | `--NUM_INT -> 5 [2248:72]
26160 | | | | |--COMMA -> , [2248:73]
26161 | | | | `--EXPR -> EXPR [2248:75]
26162 | | | | `--STRING_LITERAL -> "4, 8" [2248:75]
26163 | | | `--RPAREN -> ) [2248:81]
26164 | | |--COMMA -> , [2248:82]
26165 | | |--EXPR -> EXPR [2249:22]
26166 | | | `--PLUS -> + [2249:22]
26167 | | | |--STRING_LITERAL -> "51:12: " [2249:12]
26168 | | | `--METHOD_CALL -> ( [2249:39]
26169 | | | |--IDENT -> getCheckMessage [2249:24]
26170 | | | |--ELIST -> ELIST [2249:40]
26171 | | | | |--EXPR -> EXPR [2249:40]
26172 | | | | | `--IDENT -> MSG_ERROR [2249:40]
26173 | | | | |--COMMA -> , [2249:49]
26174 | | | | |--EXPR -> EXPR [2249:51]
26175 | | | | | `--STRING_LITERAL -> "lambda" [2249:51]
26176 | | | | |--COMMA -> , [2249:59]
26177 | | | | |--EXPR -> EXPR [2249:61]
26178 | | | | | `--NUM_INT -> 11 [2249:61]
26179 | | | | |--COMMA -> , [2249:63]
26180 | | | | `--EXPR -> EXPR [2249:65]
26181 | | | | `--NUM_INT -> 12 [2249:65]
26182 | | | `--RPAREN -> ) [2249:67]
26183 | | |--COMMA -> , [2249:68]
26184 | | |--EXPR -> EXPR [2250:22]
26185 | | | `--PLUS -> + [2250:22]
26186 | | | |--STRING_LITERAL -> "52:10: " [2250:12]
26187 | | | `--METHOD_CALL -> ( [2250:39]
26188 | | | |--IDENT -> getCheckMessage [2250:24]
26189 | | | |--ELIST -> ELIST [2250:40]
26190 | | | | |--EXPR -> EXPR [2250:40]
26191 | | | | | `--IDENT -> MSG_ERROR [2250:40]
26192 | | | | |--COMMA -> , [2250:49]
26193 | | | | |--EXPR -> EXPR [2250:51]
26194 | | | | | `--STRING_LITERAL -> "block lcurly" [2250:51]
26195 | | | | |--COMMA -> , [2250:65]
26196 | | | | |--EXPR -> EXPR [2250:67]
26197 | | | | | `--NUM_INT -> 9 [2250:67]
26198 | | | | |--COMMA -> , [2250:68]
26199 | | | | `--EXPR -> EXPR [2250:70]
26200 | | | | `--NUM_INT -> 8 [2250:70]
26201 | | | `--RPAREN -> ) [2250:71]
26202 | | |--COMMA -> , [2250:72]
26203 | | |--EXPR -> EXPR [2251:21]
26204 | | | `--PLUS -> + [2251:21]
26205 | | | |--STRING_LITERAL -> "64:8: " [2251:12]
26206 | | | `--METHOD_CALL -> ( [2251:38]
26207 | | | |--IDENT -> getCheckMessage [2251:23]
26208 | | | |--ELIST -> ELIST [2251:39]
26209 | | | | |--EXPR -> EXPR [2251:39]
26210 | | | | | `--IDENT -> MSG_CHILD_ERROR [2251:39]
26211 | | | | |--COMMA -> , [2251:54]
26212 | | | | |--EXPR -> EXPR [2251:56]
26213 | | | | | `--STRING_LITERAL -> "block" [2251:56]
26214 | | | | |--COMMA -> , [2251:63]
26215 | | | | |--EXPR -> EXPR [2251:65]
26216 | | | | | `--NUM_INT -> 7 [2251:65]
26217 | | | | |--COMMA -> , [2251:66]
26218 | | | | `--EXPR -> EXPR [2251:68]
26219 | | | | `--NUM_INT -> 6 [2251:68]
26220 | | | `--RPAREN -> ) [2251:69]
26221 | | |--COMMA -> , [2251:70]
26222 | | |--EXPR -> EXPR [2252:21]
26223 | | | `--PLUS -> + [2252:21]
26224 | | | |--STRING_LITERAL -> "65:6: " [2252:12]
26225 | | | `--METHOD_CALL -> ( [2252:38]
26226 | | | |--IDENT -> getCheckMessage [2252:23]
26227 | | | |--ELIST -> ELIST [2252:39]
26228 | | | | |--EXPR -> EXPR [2252:39]
26229 | | | | | `--IDENT -> MSG_ERROR [2252:39]
26230 | | | | |--COMMA -> , [2252:48]
26231 | | | | |--EXPR -> EXPR [2252:50]
26232 | | | | | `--STRING_LITERAL -> "block rcurly" [2252:50]
26233 | | | | |--COMMA -> , [2252:64]
26234 | | | | |--EXPR -> EXPR [2252:66]
26235 | | | | | `--NUM_INT -> 5 [2252:66]
26236 | | | | |--COMMA -> , [2252:67]
26237 | | | | `--EXPR -> EXPR [2252:69]
26238 | | | | `--NUM_INT -> 4 [2252:69]
26239 | | | `--RPAREN -> ) [2252:70]
26240 | | |--COMMA -> , [2252:71]
26241 | | |--EXPR -> EXPR [2253:23]
26242 | | | `--PLUS -> + [2253:23]
26243 | | | |--STRING_LITERAL -> "179:10: " [2253:12]
26244 | | | `--METHOD_CALL -> ( [2253:40]
26245 | | | |--IDENT -> getCheckMessage [2253:25]
26246 | | | |--ELIST -> ELIST [2253:41]
26247 | | | | |--EXPR -> EXPR [2253:41]
26248 | | | | | `--IDENT -> MSG_CHILD_ERROR [2253:41]
26249 | | | | |--COMMA -> , [2253:56]
26250 | | | | |--EXPR -> EXPR [2253:58]
26251 | | | | | `--STRING_LITERAL -> "block" [2253:58]
26252 | | | | |--COMMA -> , [2253:65]
26253 | | | | |--EXPR -> EXPR [2253:67]
26254 | | | | | `--NUM_INT -> 9 [2253:67]
26255 | | | | |--COMMA -> , [2253:68]
26256 | | | | `--EXPR -> EXPR [2253:70]
26257 | | | | `--NUM_INT -> 10 [2253:70]
26258 | | | `--RPAREN -> ) [2253:72]
26259 | | |--COMMA -> , [2253:73]
26260 | | |--EXPR -> EXPR [2254:23]
26261 | | | `--PLUS -> + [2254:23]
26262 | | | |--STRING_LITERAL -> "180:12: " [2254:12]
26263 | | | `--METHOD_CALL -> ( [2254:40]
26264 | | | |--IDENT -> getCheckMessage [2254:25]
26265 | | | |--ELIST -> ELIST [2254:41]
26266 | | | | |--EXPR -> EXPR [2254:41]
26267 | | | | | `--IDENT -> MSG_CHILD_ERROR [2254:41]
26268 | | | | |--COMMA -> , [2254:56]
26269 | | | | |--EXPR -> EXPR [2254:58]
26270 | | | | | `--STRING_LITERAL -> "block" [2254:58]
26271 | | | | |--COMMA -> , [2254:65]
26272 | | | | |--EXPR -> EXPR [2254:67]
26273 | | | | | `--NUM_INT -> 11 [2254:67]
26274 | | | | |--COMMA -> , [2254:69]
26275 | | | | `--EXPR -> EXPR [2254:71]
26276 | | | | `--NUM_INT -> 10 [2254:71]
26277 | | | `--RPAREN -> ) [2254:73]
26278 | | |--COMMA -> , [2254:74]
26279 | | |--EXPR -> EXPR [2255:22]
26280 | | | `--PLUS -> + [2255:22]
26281 | | | |--STRING_LITERAL -> "185:8: " [2255:12]
26282 | | | `--METHOD_CALL -> ( [2255:39]
26283 | | | |--IDENT -> getCheckMessage [2255:24]
26284 | | | |--ELIST -> ELIST [2255:40]
26285 | | | | |--EXPR -> EXPR [2255:40]
26286 | | | | | `--IDENT -> MSG_ERROR [2255:40]
26287 | | | | |--COMMA -> , [2255:49]
26288 | | | | |--EXPR -> EXPR [2255:51]
26289 | | | | | `--STRING_LITERAL -> "block rcurly" [2255:51]
26290 | | | | |--COMMA -> , [2255:65]
26291 | | | | |--EXPR -> EXPR [2255:67]
26292 | | | | | `--NUM_INT -> 7 [2255:67]
26293 | | | | |--COMMA -> , [2255:68]
26294 | | | | `--EXPR -> EXPR [2255:70]
26295 | | | | `--NUM_INT -> 8 [2255:70]
26296 | | | `--RPAREN -> ) [2255:71]
26297 | | |--COMMA -> , [2255:72]
26298 | | `--RCURLY -> } [2256:8]
26299 | |--SEMI -> ; [2256:9]
26300 | |--EXPR -> EXPR [2257:19]
26301 | | `--METHOD_CALL -> ( [2257:19]
26302 | | |--IDENT -> verifyWarns [2257:8]
26303 | | |--ELIST -> ELIST [2257:20]
26304 | | | |--EXPR -> EXPR [2257:20]
26305 | | | | `--IDENT -> checkConfig [2257:20]
26306 | | | |--COMMA -> , [2257:31]
26307 | | | |--EXPR -> EXPR [2257:40]
26308 | | | | `--METHOD_CALL -> ( [2257:40]
26309 | | | | |--IDENT -> getPath [2257:33]
26310 | | | | |--ELIST -> ELIST [2257:41]
26311 | | | | | `--EXPR -> EXPR [2257:41]
26312 | | | | | `--STRING_LITERAL -> "InputIndentationLambda1.java" [2257:41]
26313 | | | | `--RPAREN -> ) [2257:71]
26314 | | | |--COMMA -> , [2257:72]
26315 | | | `--EXPR -> EXPR [2257:74]
26316 | | | `--IDENT -> expected [2257:74]
26317 | | `--RPAREN -> ) [2257:82]
26318 | |--SEMI -> ; [2257:83]
26319 | `--RCURLY -> } [2258:4]
26320 |--METHOD_DEF -> METHOD_DEF [2260:4]
26321 | |--MODIFIERS -> MODIFIERS [2260:4]
26322 | | |--ANNOTATION -> ANNOTATION [2260:4]
26323 | | | |--AT -> @ [2260:4]
26324 | | | `--IDENT -> Test [2260:5]
26325 | | `--LITERAL_PUBLIC -> public [2261:4]
26326 | |--TYPE -> TYPE [2261:11]
26327 | | `--LITERAL_VOID -> void [2261:11]
26328 | |--IDENT -> testLambda2 [2261:16]
26329 | |--LPAREN -> ( [2261:27]
26330 | |--PARAMETERS -> PARAMETERS [2261:28]
26331 | |--RPAREN -> ) [2261:28]
26332 | |--LITERAL_THROWS -> throws [2261:30]
26333 | | `--IDENT -> Exception [2261:37]
26334 | `--SLIST -> { [2261:47]
26335 | |--VARIABLE_DEF -> VARIABLE_DEF [2262:8]
26336 | | |--MODIFIERS -> MODIFIERS [2262:8]
26337 | | | `--FINAL -> final [2262:8]
26338 | | |--TYPE -> TYPE [2262:14]
26339 | | | `--IDENT -> DefaultConfiguration [2262:14]
26340 | | |--IDENT -> checkConfig [2262:35]
26341 | | `--ASSIGN -> = [2262:47]
26342 | | `--EXPR -> EXPR [2262:67]
26343 | | `--METHOD_CALL -> ( [2262:67]
26344 | | |--IDENT -> createModuleConfig [2262:49]
26345 | | |--ELIST -> ELIST [2262:84]
26346 | | | `--EXPR -> EXPR [2262:84]
26347 | | | `--DOT -> . [2262:84]
26348 | | | |--IDENT -> IndentationCheck [2262:68]
26349 | | | `--LITERAL_CLASS -> class [2262:85]
26350 | | `--RPAREN -> ) [2262:90]
26351 | |--SEMI -> ; [2262:91]
26352 | |--EXPR -> EXPR [2263:32]
26353 | | `--METHOD_CALL -> ( [2263:32]
26354 | | |--DOT -> . [2263:19]
26355 | | | |--IDENT -> checkConfig [2263:8]
26356 | | | `--IDENT -> addAttribute [2263:20]
26357 | | |--ELIST -> ELIST [2263:33]
26358 | | | |--EXPR -> EXPR [2263:33]
26359 | | | | `--STRING_LITERAL -> "tabWidth" [2263:33]
26360 | | | |--COMMA -> , [2263:43]
26361 | | | `--EXPR -> EXPR [2263:45]
26362 | | | `--STRING_LITERAL -> "4" [2263:45]
26363 | | `--RPAREN -> ) [2263:48]
26364 | |--SEMI -> ; [2263:49]
26365 | |--EXPR -> EXPR [2264:32]
26366 | | `--METHOD_CALL -> ( [2264:32]
26367 | | |--DOT -> . [2264:19]
26368 | | | |--IDENT -> checkConfig [2264:8]
26369 | | | `--IDENT -> addAttribute [2264:20]
26370 | | |--ELIST -> ELIST [2264:33]
26371 | | | |--EXPR -> EXPR [2264:33]
26372 | | | | `--STRING_LITERAL -> "basicOffset" [2264:33]
26373 | | | |--COMMA -> , [2264:46]
26374 | | | `--EXPR -> EXPR [2264:48]
26375 | | | `--STRING_LITERAL -> "4" [2264:48]
26376 | | `--RPAREN -> ) [2264:51]
26377 | |--SEMI -> ; [2264:52]
26378 | |--EXPR -> EXPR [2265:32]
26379 | | `--METHOD_CALL -> ( [2265:32]
26380 | | |--DOT -> . [2265:19]
26381 | | | |--IDENT -> checkConfig [2265:8]
26382 | | | `--IDENT -> addAttribute [2265:20]
26383 | | |--ELIST -> ELIST [2265:33]
26384 | | | |--EXPR -> EXPR [2265:33]
26385 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2265:33]
26386 | | | |--COMMA -> , [2265:58]
26387 | | | `--EXPR -> EXPR [2265:60]
26388 | | | `--STRING_LITERAL -> "8" [2265:60]
26389 | | `--RPAREN -> ) [2265:63]
26390 | |--SEMI -> ; [2265:64]
26391 | |--VARIABLE_DEF -> VARIABLE_DEF [2266:8]
26392 | | |--MODIFIERS -> MODIFIERS [2266:8]
26393 | | | `--FINAL -> final [2266:8]
26394 | | |--TYPE -> TYPE [2266:20]
26395 | | | `--ARRAY_DECLARATOR -> [ [2266:20]
26396 | | | |--IDENT -> String [2266:14]
26397 | | | `--RBRACK -> ] [2266:21]
26398 | | |--IDENT -> expected [2266:23]
26399 | | `--ASSIGN -> = [2266:32]
26400 | | `--EXPR -> EXPR [2266:44]
26401 | | `--DOT -> . [2266:44]
26402 | | |--IDENT -> CommonUtil [2266:34]
26403 | | `--IDENT -> EMPTY_STRING_ARRAY [2266:45]
26404 | |--SEMI -> ; [2266:63]
26405 | |--EXPR -> EXPR [2267:19]
26406 | | `--METHOD_CALL -> ( [2267:19]
26407 | | |--IDENT -> verifyWarns [2267:8]
26408 | | |--ELIST -> ELIST [2267:20]
26409 | | | |--EXPR -> EXPR [2267:20]
26410 | | | | `--IDENT -> checkConfig [2267:20]
26411 | | | |--COMMA -> , [2267:31]
26412 | | | |--EXPR -> EXPR [2267:40]
26413 | | | | `--METHOD_CALL -> ( [2267:40]
26414 | | | | |--IDENT -> getPath [2267:33]
26415 | | | | |--ELIST -> ELIST [2267:41]
26416 | | | | | `--EXPR -> EXPR [2267:41]
26417 | | | | | `--STRING_LITERAL -> "InputIndentationLambda2.java" [2267:41]
26418 | | | | `--RPAREN -> ) [2267:71]
26419 | | | |--COMMA -> , [2267:72]
26420 | | | `--EXPR -> EXPR [2267:74]
26421 | | | `--IDENT -> expected [2267:74]
26422 | | `--RPAREN -> ) [2267:82]
26423 | |--SEMI -> ; [2267:83]
26424 | `--RCURLY -> } [2268:4]
26425 |--METHOD_DEF -> METHOD_DEF [2270:4]
26426 | |--MODIFIERS -> MODIFIERS [2270:4]
26427 | | |--ANNOTATION -> ANNOTATION [2270:4]
26428 | | | |--AT -> @ [2270:4]
26429 | | | `--IDENT -> Test [2270:5]
26430 | | `--LITERAL_PUBLIC -> public [2271:4]
26431 | |--TYPE -> TYPE [2271:11]
26432 | | `--LITERAL_VOID -> void [2271:11]
26433 | |--IDENT -> testLambda3 [2271:16]
26434 | |--LPAREN -> ( [2271:27]
26435 | |--PARAMETERS -> PARAMETERS [2271:28]
26436 | |--RPAREN -> ) [2271:28]
26437 | |--LITERAL_THROWS -> throws [2271:30]
26438 | | `--IDENT -> Exception [2271:37]
26439 | `--SLIST -> { [2271:47]
26440 | |--VARIABLE_DEF -> VARIABLE_DEF [2272:8]
26441 | | |--MODIFIERS -> MODIFIERS [2272:8]
26442 | | | `--FINAL -> final [2272:8]
26443 | | |--TYPE -> TYPE [2272:14]
26444 | | | `--IDENT -> DefaultConfiguration [2272:14]
26445 | | |--IDENT -> checkConfig [2272:35]
26446 | | `--ASSIGN -> = [2272:47]
26447 | | `--EXPR -> EXPR [2272:67]
26448 | | `--METHOD_CALL -> ( [2272:67]
26449 | | |--IDENT -> createModuleConfig [2272:49]
26450 | | |--ELIST -> ELIST [2272:84]
26451 | | | `--EXPR -> EXPR [2272:84]
26452 | | | `--DOT -> . [2272:84]
26453 | | | |--IDENT -> IndentationCheck [2272:68]
26454 | | | `--LITERAL_CLASS -> class [2272:85]
26455 | | `--RPAREN -> ) [2272:90]
26456 | |--SEMI -> ; [2272:91]
26457 | |--EXPR -> EXPR [2273:32]
26458 | | `--METHOD_CALL -> ( [2273:32]
26459 | | |--DOT -> . [2273:19]
26460 | | | |--IDENT -> checkConfig [2273:8]
26461 | | | `--IDENT -> addAttribute [2273:20]
26462 | | |--ELIST -> ELIST [2273:33]
26463 | | | |--EXPR -> EXPR [2273:33]
26464 | | | | `--STRING_LITERAL -> "tabWidth" [2273:33]
26465 | | | |--COMMA -> , [2273:43]
26466 | | | `--EXPR -> EXPR [2273:45]
26467 | | | `--STRING_LITERAL -> "4" [2273:45]
26468 | | `--RPAREN -> ) [2273:48]
26469 | |--SEMI -> ; [2273:49]
26470 | |--EXPR -> EXPR [2274:32]
26471 | | `--METHOD_CALL -> ( [2274:32]
26472 | | |--DOT -> . [2274:19]
26473 | | | |--IDENT -> checkConfig [2274:8]
26474 | | | `--IDENT -> addAttribute [2274:20]
26475 | | |--ELIST -> ELIST [2274:33]
26476 | | | |--EXPR -> EXPR [2274:33]
26477 | | | | `--STRING_LITERAL -> "basicOffset" [2274:33]
26478 | | | |--COMMA -> , [2274:46]
26479 | | | `--EXPR -> EXPR [2274:48]
26480 | | | `--STRING_LITERAL -> "4" [2274:48]
26481 | | `--RPAREN -> ) [2274:51]
26482 | |--SEMI -> ; [2274:52]
26483 | |--EXPR -> EXPR [2275:32]
26484 | | `--METHOD_CALL -> ( [2275:32]
26485 | | |--DOT -> . [2275:19]
26486 | | | |--IDENT -> checkConfig [2275:8]
26487 | | | `--IDENT -> addAttribute [2275:20]
26488 | | |--ELIST -> ELIST [2275:33]
26489 | | | |--EXPR -> EXPR [2275:33]
26490 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2275:33]
26491 | | | |--COMMA -> , [2275:58]
26492 | | | `--EXPR -> EXPR [2275:60]
26493 | | | `--STRING_LITERAL -> "8" [2275:60]
26494 | | `--RPAREN -> ) [2275:63]
26495 | |--SEMI -> ; [2275:64]
26496 | |--VARIABLE_DEF -> VARIABLE_DEF [2276:8]
26497 | | |--MODIFIERS -> MODIFIERS [2276:8]
26498 | | | `--FINAL -> final [2276:8]
26499 | | |--TYPE -> TYPE [2276:20]
26500 | | | `--ARRAY_DECLARATOR -> [ [2276:20]
26501 | | | |--IDENT -> String [2276:14]
26502 | | | `--RBRACK -> ] [2276:21]
26503 | | |--IDENT -> expected [2276:23]
26504 | | `--ASSIGN -> = [2276:32]
26505 | | `--ARRAY_INIT -> { [2276:34]
26506 | | |--EXPR -> EXPR [2277:22]
26507 | | | `--PLUS -> + [2277:22]
26508 | | | |--STRING_LITERAL -> "15:13: " [2277:12]
26509 | | | `--METHOD_CALL -> ( [2277:39]
26510 | | | |--IDENT -> getCheckMessage [2277:24]
26511 | | | |--ELIST -> ELIST [2277:40]
26512 | | | | |--EXPR -> EXPR [2277:40]
26513 | | | | | `--IDENT -> MSG_CHILD_ERROR [2277:40]
26514 | | | | |--COMMA -> , [2277:55]
26515 | | | | |--EXPR -> EXPR [2277:57]
26516 | | | | | `--STRING_LITERAL -> "method def" [2277:57]
26517 | | | | |--COMMA -> , [2277:69]
26518 | | | | |--EXPR -> EXPR [2277:71]
26519 | | | | | `--NUM_INT -> 12 [2277:71]
26520 | | | | |--COMMA -> , [2277:73]
26521 | | | | `--EXPR -> EXPR [2277:75]
26522 | | | | `--NUM_INT -> 8 [2277:75]
26523 | | | `--RPAREN -> ) [2277:76]
26524 | | |--COMMA -> , [2277:77]
26525 | | |--EXPR -> EXPR [2278:22]
26526 | | | `--PLUS -> + [2278:22]
26527 | | | |--STRING_LITERAL -> "29:13: " [2278:12]
26528 | | | `--METHOD_CALL -> ( [2278:39]
26529 | | | |--IDENT -> getCheckMessage [2278:24]
26530 | | | |--ELIST -> ELIST [2278:40]
26531 | | | | |--EXPR -> EXPR [2278:40]
26532 | | | | | `--IDENT -> MSG_CHILD_ERROR [2278:40]
26533 | | | | |--COMMA -> , [2278:55]
26534 | | | | |--EXPR -> EXPR [2278:57]
26535 | | | | | `--STRING_LITERAL -> "method def" [2278:57]
26536 | | | | |--COMMA -> , [2278:69]
26537 | | | | |--EXPR -> EXPR [2278:71]
26538 | | | | | `--NUM_INT -> 12 [2278:71]
26539 | | | | |--COMMA -> , [2278:73]
26540 | | | | `--EXPR -> EXPR [2278:75]
26541 | | | | `--NUM_INT -> 8 [2278:75]
26542 | | | `--RPAREN -> ) [2278:76]
26543 | | |--COMMA -> , [2278:77]
26544 | | |--EXPR -> EXPR [2279:22]
26545 | | | `--PLUS -> + [2279:22]
26546 | | | |--STRING_LITERAL -> "30:13: " [2279:12]
26547 | | | `--METHOD_CALL -> ( [2279:39]
26548 | | | |--IDENT -> getCheckMessage [2279:24]
26549 | | | |--ELIST -> ELIST [2279:40]
26550 | | | | |--EXPR -> EXPR [2279:40]
26551 | | | | | `--IDENT -> MSG_CHILD_ERROR [2279:40]
26552 | | | | |--COMMA -> , [2279:55]
26553 | | | | |--EXPR -> EXPR [2279:57]
26554 | | | | | `--STRING_LITERAL -> "block" [2279:57]
26555 | | | | |--COMMA -> , [2279:64]
26556 | | | | |--EXPR -> EXPR [2279:66]
26557 | | | | | `--NUM_INT -> 12 [2279:66]
26558 | | | | |--COMMA -> , [2279:68]
26559 | | | | `--EXPR -> EXPR [2279:70]
26560 | | | | `--NUM_INT -> 16 [2279:70]
26561 | | | `--RPAREN -> ) [2279:72]
26562 | | |--COMMA -> , [2279:73]
26563 | | |--EXPR -> EXPR [2280:21]
26564 | | | `--PLUS -> + [2280:21]
26565 | | | |--STRING_LITERAL -> "31:9: " [2280:12]
26566 | | | `--METHOD_CALL -> ( [2280:38]
26567 | | | |--IDENT -> getCheckMessage [2280:23]
26568 | | | |--ELIST -> ELIST [2280:39]
26569 | | | | |--EXPR -> EXPR [2280:39]
26570 | | | | | `--IDENT -> MSG_ERROR [2280:39]
26571 | | | | |--COMMA -> , [2280:48]
26572 | | | | |--EXPR -> EXPR [2280:50]
26573 | | | | | `--STRING_LITERAL -> "block rcurly" [2280:50]
26574 | | | | |--COMMA -> , [2280:64]
26575 | | | | |--EXPR -> EXPR [2280:66]
26576 | | | | | `--NUM_INT -> 8 [2280:66]
26577 | | | | |--COMMA -> , [2280:67]
26578 | | | | `--EXPR -> EXPR [2280:69]
26579 | | | | `--NUM_INT -> 12 [2280:69]
26580 | | | `--RPAREN -> ) [2280:71]
26581 | | |--COMMA -> , [2280:72]
26582 | | |--EXPR -> EXPR [2281:22]
26583 | | | `--PLUS -> + [2281:22]
26584 | | | |--STRING_LITERAL -> "65:13: " [2281:12]
26585 | | | `--METHOD_CALL -> ( [2281:39]
26586 | | | |--IDENT -> getCheckMessage [2281:24]
26587 | | | |--ELIST -> ELIST [2281:40]
26588 | | | | |--EXPR -> EXPR [2281:40]
26589 | | | | | `--IDENT -> MSG_CHILD_ERROR [2281:40]
26590 | | | | |--COMMA -> , [2281:55]
26591 | | | | |--EXPR -> EXPR [2281:57]
26592 | | | | | `--STRING_LITERAL -> "method def" [2281:57]
26593 | | | | |--COMMA -> , [2281:69]
26594 | | | | |--EXPR -> EXPR [2281:71]
26595 | | | | | `--NUM_INT -> 12 [2281:71]
26596 | | | | |--COMMA -> , [2281:73]
26597 | | | | `--EXPR -> EXPR [2281:75]
26598 | | | | `--NUM_INT -> 8 [2281:75]
26599 | | | `--RPAREN -> ) [2281:76]
26600 | | |--COMMA -> , [2281:77]
26601 | | |--EXPR -> EXPR [2282:22]
26602 | | | `--PLUS -> + [2282:22]
26603 | | | |--STRING_LITERAL -> "87:13: " [2282:12]
26604 | | | `--METHOD_CALL -> ( [2282:39]
26605 | | | |--IDENT -> getCheckMessage [2282:24]
26606 | | | |--ELIST -> ELIST [2282:40]
26607 | | | | |--EXPR -> EXPR [2282:40]
26608 | | | | | `--IDENT -> MSG_ERROR [2282:40]
26609 | | | | |--COMMA -> , [2282:49]
26610 | | | | |--EXPR -> EXPR [2282:51]
26611 | | | | | `--STRING_LITERAL -> "method def rcurly" [2282:51]
26612 | | | | |--COMMA -> , [2282:70]
26613 | | | | |--EXPR -> EXPR [2282:72]
26614 | | | | | `--NUM_INT -> 12 [2282:72]
26615 | | | | |--COMMA -> , [2282:74]
26616 | | | | `--EXPR -> EXPR [2282:76]
26617 | | | | `--NUM_INT -> 8 [2282:76]
26618 | | | `--RPAREN -> ) [2282:77]
26619 | | |--COMMA -> , [2282:78]
26620 | | `--RCURLY -> } [2283:8]
26621 | |--SEMI -> ; [2283:9]
26622 | |--EXPR -> EXPR [2284:19]
26623 | | `--METHOD_CALL -> ( [2284:19]
26624 | | |--IDENT -> verifyWarns [2284:8]
26625 | | |--ELIST -> ELIST [2284:20]
26626 | | | |--EXPR -> EXPR [2284:20]
26627 | | | | `--IDENT -> checkConfig [2284:20]
26628 | | | |--COMMA -> , [2284:31]
26629 | | | |--EXPR -> EXPR [2284:40]
26630 | | | | `--METHOD_CALL -> ( [2284:40]
26631 | | | | |--IDENT -> getPath [2284:33]
26632 | | | | |--ELIST -> ELIST [2284:41]
26633 | | | | | `--EXPR -> EXPR [2284:41]
26634 | | | | | `--STRING_LITERAL -> "InputIndentationLambda3.java" [2284:41]
26635 | | | | `--RPAREN -> ) [2284:71]
26636 | | | |--COMMA -> , [2284:72]
26637 | | | `--EXPR -> EXPR [2284:74]
26638 | | | `--IDENT -> expected [2284:74]
26639 | | `--RPAREN -> ) [2284:82]
26640 | |--SEMI -> ; [2284:83]
26641 | `--RCURLY -> } [2285:4]
26642 |--METHOD_DEF -> METHOD_DEF [2287:4]
26643 | |--MODIFIERS -> MODIFIERS [2287:4]
26644 | | |--ANNOTATION -> ANNOTATION [2287:4]
26645 | | | |--AT -> @ [2287:4]
26646 | | | `--IDENT -> Test [2287:5]
26647 | | `--LITERAL_PUBLIC -> public [2288:4]
26648 | |--TYPE -> TYPE [2288:11]
26649 | | `--LITERAL_VOID -> void [2288:11]
26650 | |--IDENT -> testLambda4 [2288:16]
26651 | |--LPAREN -> ( [2288:27]
26652 | |--PARAMETERS -> PARAMETERS [2288:28]
26653 | |--RPAREN -> ) [2288:28]
26654 | |--LITERAL_THROWS -> throws [2288:30]
26655 | | `--IDENT -> Exception [2288:37]
26656 | `--SLIST -> { [2288:47]
26657 | |--VARIABLE_DEF -> VARIABLE_DEF [2289:8]
26658 | | |--MODIFIERS -> MODIFIERS [2289:8]
26659 | | | `--FINAL -> final [2289:8]
26660 | | |--TYPE -> TYPE [2289:14]
26661 | | | `--IDENT -> DefaultConfiguration [2289:14]
26662 | | |--IDENT -> checkConfig [2289:35]
26663 | | `--ASSIGN -> = [2289:47]
26664 | | `--EXPR -> EXPR [2289:67]
26665 | | `--METHOD_CALL -> ( [2289:67]
26666 | | |--IDENT -> createModuleConfig [2289:49]
26667 | | |--ELIST -> ELIST [2289:84]
26668 | | | `--EXPR -> EXPR [2289:84]
26669 | | | `--DOT -> . [2289:84]
26670 | | | |--IDENT -> IndentationCheck [2289:68]
26671 | | | `--LITERAL_CLASS -> class [2289:85]
26672 | | `--RPAREN -> ) [2289:90]
26673 | |--SEMI -> ; [2289:91]
26674 | |--EXPR -> EXPR [2290:32]
26675 | | `--METHOD_CALL -> ( [2290:32]
26676 | | |--DOT -> . [2290:19]
26677 | | | |--IDENT -> checkConfig [2290:8]
26678 | | | `--IDENT -> addAttribute [2290:20]
26679 | | |--ELIST -> ELIST [2290:33]
26680 | | | |--EXPR -> EXPR [2290:33]
26681 | | | | `--STRING_LITERAL -> "tabWidth" [2290:33]
26682 | | | |--COMMA -> , [2290:43]
26683 | | | `--EXPR -> EXPR [2290:45]
26684 | | | `--STRING_LITERAL -> "4" [2290:45]
26685 | | `--RPAREN -> ) [2290:48]
26686 | |--SEMI -> ; [2290:49]
26687 | |--EXPR -> EXPR [2291:32]
26688 | | `--METHOD_CALL -> ( [2291:32]
26689 | | |--DOT -> . [2291:19]
26690 | | | |--IDENT -> checkConfig [2291:8]
26691 | | | `--IDENT -> addAttribute [2291:20]
26692 | | |--ELIST -> ELIST [2291:33]
26693 | | | |--EXPR -> EXPR [2291:33]
26694 | | | | `--STRING_LITERAL -> "basicOffset" [2291:33]
26695 | | | |--COMMA -> , [2291:46]
26696 | | | `--EXPR -> EXPR [2291:48]
26697 | | | `--STRING_LITERAL -> "4" [2291:48]
26698 | | `--RPAREN -> ) [2291:51]
26699 | |--SEMI -> ; [2291:52]
26700 | |--EXPR -> EXPR [2292:32]
26701 | | `--METHOD_CALL -> ( [2292:32]
26702 | | |--DOT -> . [2292:19]
26703 | | | |--IDENT -> checkConfig [2292:8]
26704 | | | `--IDENT -> addAttribute [2292:20]
26705 | | |--ELIST -> ELIST [2292:33]
26706 | | | |--EXPR -> EXPR [2292:33]
26707 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2292:33]
26708 | | | |--COMMA -> , [2292:58]
26709 | | | `--EXPR -> EXPR [2292:60]
26710 | | | `--STRING_LITERAL -> "8" [2292:60]
26711 | | `--RPAREN -> ) [2292:63]
26712 | |--SEMI -> ; [2292:64]
26713 | |--VARIABLE_DEF -> VARIABLE_DEF [2293:8]
26714 | | |--MODIFIERS -> MODIFIERS [2293:8]
26715 | | | `--FINAL -> final [2293:8]
26716 | | |--TYPE -> TYPE [2293:20]
26717 | | | `--ARRAY_DECLARATOR -> [ [2293:20]
26718 | | | |--IDENT -> String [2293:14]
26719 | | | `--RBRACK -> ] [2293:21]
26720 | | |--IDENT -> expected [2293:23]
26721 | | `--ASSIGN -> = [2293:32]
26722 | | `--EXPR -> EXPR [2293:44]
26723 | | `--DOT -> . [2293:44]
26724 | | |--IDENT -> CommonUtil [2293:34]
26725 | | `--IDENT -> EMPTY_STRING_ARRAY [2293:45]
26726 | |--SEMI -> ; [2293:63]
26727 | |--EXPR -> EXPR [2294:19]
26728 | | `--METHOD_CALL -> ( [2294:19]
26729 | | |--IDENT -> verifyWarns [2294:8]
26730 | | |--ELIST -> ELIST [2294:20]
26731 | | | |--EXPR -> EXPR [2294:20]
26732 | | | | `--IDENT -> checkConfig [2294:20]
26733 | | | |--COMMA -> , [2294:31]
26734 | | | |--EXPR -> EXPR [2294:40]
26735 | | | | `--METHOD_CALL -> ( [2294:40]
26736 | | | | |--IDENT -> getPath [2294:33]
26737 | | | | |--ELIST -> ELIST [2294:41]
26738 | | | | | `--EXPR -> EXPR [2294:41]
26739 | | | | | `--STRING_LITERAL -> "InputIndentationLambda4.java" [2294:41]
26740 | | | | `--RPAREN -> ) [2294:71]
26741 | | | |--COMMA -> , [2294:72]
26742 | | | `--EXPR -> EXPR [2294:74]
26743 | | | `--IDENT -> expected [2294:74]
26744 | | `--RPAREN -> ) [2294:82]
26745 | |--SEMI -> ; [2294:83]
26746 | `--RCURLY -> } [2295:4]
26747 |--METHOD_DEF -> METHOD_DEF [2297:4]
26748 | |--MODIFIERS -> MODIFIERS [2297:4]
26749 | | |--ANNOTATION -> ANNOTATION [2297:4]
26750 | | | |--AT -> @ [2297:4]
26751 | | | `--IDENT -> Test [2297:5]
26752 | | `--LITERAL_PUBLIC -> public [2298:4]
26753 | |--TYPE -> TYPE [2298:11]
26754 | | `--LITERAL_VOID -> void [2298:11]
26755 | |--IDENT -> testLambda5 [2298:16]
26756 | |--LPAREN -> ( [2298:27]
26757 | |--PARAMETERS -> PARAMETERS [2298:28]
26758 | |--RPAREN -> ) [2298:28]
26759 | |--LITERAL_THROWS -> throws [2298:30]
26760 | | `--IDENT -> Exception [2298:37]
26761 | `--SLIST -> { [2298:47]
26762 | |--VARIABLE_DEF -> VARIABLE_DEF [2299:8]
26763 | | |--MODIFIERS -> MODIFIERS [2299:8]
26764 | | | `--FINAL -> final [2299:8]
26765 | | |--TYPE -> TYPE [2299:14]
26766 | | | `--IDENT -> DefaultConfiguration [2299:14]
26767 | | |--IDENT -> checkConfig [2299:35]
26768 | | `--ASSIGN -> = [2299:47]
26769 | | `--EXPR -> EXPR [2299:67]
26770 | | `--METHOD_CALL -> ( [2299:67]
26771 | | |--IDENT -> createModuleConfig [2299:49]
26772 | | |--ELIST -> ELIST [2299:84]
26773 | | | `--EXPR -> EXPR [2299:84]
26774 | | | `--DOT -> . [2299:84]
26775 | | | |--IDENT -> IndentationCheck [2299:68]
26776 | | | `--LITERAL_CLASS -> class [2299:85]
26777 | | `--RPAREN -> ) [2299:90]
26778 | |--SEMI -> ; [2299:91]
26779 | |--EXPR -> EXPR [2300:32]
26780 | | `--METHOD_CALL -> ( [2300:32]
26781 | | |--DOT -> . [2300:19]
26782 | | | |--IDENT -> checkConfig [2300:8]
26783 | | | `--IDENT -> addAttribute [2300:20]
26784 | | |--ELIST -> ELIST [2300:33]
26785 | | | |--EXPR -> EXPR [2300:33]
26786 | | | | `--STRING_LITERAL -> "tabWidth" [2300:33]
26787 | | | |--COMMA -> , [2300:43]
26788 | | | `--EXPR -> EXPR [2300:45]
26789 | | | `--STRING_LITERAL -> "3" [2300:45]
26790 | | `--RPAREN -> ) [2300:48]
26791 | |--SEMI -> ; [2300:49]
26792 | |--EXPR -> EXPR [2301:32]
26793 | | `--METHOD_CALL -> ( [2301:32]
26794 | | |--DOT -> . [2301:19]
26795 | | | |--IDENT -> checkConfig [2301:8]
26796 | | | `--IDENT -> addAttribute [2301:20]
26797 | | |--ELIST -> ELIST [2301:33]
26798 | | | |--EXPR -> EXPR [2301:33]
26799 | | | | `--STRING_LITERAL -> "basicOffset" [2301:33]
26800 | | | |--COMMA -> , [2301:46]
26801 | | | `--EXPR -> EXPR [2301:48]
26802 | | | `--STRING_LITERAL -> "3" [2301:48]
26803 | | `--RPAREN -> ) [2301:51]
26804 | |--SEMI -> ; [2301:52]
26805 | |--EXPR -> EXPR [2302:32]
26806 | | `--METHOD_CALL -> ( [2302:32]
26807 | | |--DOT -> . [2302:19]
26808 | | | |--IDENT -> checkConfig [2302:8]
26809 | | | `--IDENT -> addAttribute [2302:20]
26810 | | |--ELIST -> ELIST [2302:33]
26811 | | | |--EXPR -> EXPR [2302:33]
26812 | | | | `--STRING_LITERAL -> "caseIndent" [2302:33]
26813 | | | |--COMMA -> , [2302:45]
26814 | | | `--EXPR -> EXPR [2302:47]
26815 | | | `--STRING_LITERAL -> "0" [2302:47]
26816 | | `--RPAREN -> ) [2302:50]
26817 | |--SEMI -> ; [2302:51]
26818 | |--EXPR -> EXPR [2303:32]
26819 | | `--METHOD_CALL -> ( [2303:32]
26820 | | |--DOT -> . [2303:19]
26821 | | | |--IDENT -> checkConfig [2303:8]
26822 | | | `--IDENT -> addAttribute [2303:20]
26823 | | |--ELIST -> ELIST [2303:33]
26824 | | | |--EXPR -> EXPR [2303:33]
26825 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2303:33]
26826 | | | |--COMMA -> , [2303:58]
26827 | | | `--EXPR -> EXPR [2303:60]
26828 | | | `--STRING_LITERAL -> "6" [2303:60]
26829 | | `--RPAREN -> ) [2303:63]
26830 | |--SEMI -> ; [2303:64]
26831 | |--VARIABLE_DEF -> VARIABLE_DEF [2304:8]
26832 | | |--MODIFIERS -> MODIFIERS [2304:8]
26833 | | | `--FINAL -> final [2304:8]
26834 | | |--TYPE -> TYPE [2304:20]
26835 | | | `--ARRAY_DECLARATOR -> [ [2304:20]
26836 | | | |--IDENT -> String [2304:14]
26837 | | | `--RBRACK -> ] [2304:21]
26838 | | |--IDENT -> expected [2304:23]
26839 | | `--ASSIGN -> = [2304:32]
26840 | | `--EXPR -> EXPR [2304:44]
26841 | | `--DOT -> . [2304:44]
26842 | | |--IDENT -> CommonUtil [2304:34]
26843 | | `--IDENT -> EMPTY_STRING_ARRAY [2304:45]
26844 | |--SEMI -> ; [2304:63]
26845 | |--EXPR -> EXPR [2305:19]
26846 | | `--METHOD_CALL -> ( [2305:19]
26847 | | |--IDENT -> verifyWarns [2305:8]
26848 | | |--ELIST -> ELIST [2305:20]
26849 | | | |--EXPR -> EXPR [2305:20]
26850 | | | | `--IDENT -> checkConfig [2305:20]
26851 | | | |--COMMA -> , [2305:31]
26852 | | | |--EXPR -> EXPR [2305:40]
26853 | | | | `--METHOD_CALL -> ( [2305:40]
26854 | | | | |--IDENT -> getPath [2305:33]
26855 | | | | |--ELIST -> ELIST [2305:41]
26856 | | | | | `--EXPR -> EXPR [2305:41]
26857 | | | | | `--STRING_LITERAL -> "InputIndentationLambda5.java" [2305:41]
26858 | | | | `--RPAREN -> ) [2305:71]
26859 | | | |--COMMA -> , [2305:72]
26860 | | | `--EXPR -> EXPR [2305:74]
26861 | | | `--IDENT -> expected [2305:74]
26862 | | `--RPAREN -> ) [2305:82]
26863 | |--SEMI -> ; [2305:83]
26864 | `--RCURLY -> } [2306:4]
26865 |--METHOD_DEF -> METHOD_DEF [2308:4]
26866 | |--MODIFIERS -> MODIFIERS [2308:4]
26867 | | |--ANNOTATION -> ANNOTATION [2308:4]
26868 | | | |--AT -> @ [2308:4]
26869 | | | `--IDENT -> Test [2308:5]
26870 | | `--LITERAL_PUBLIC -> public [2309:4]
26871 | |--TYPE -> TYPE [2309:11]
26872 | | `--LITERAL_VOID -> void [2309:11]
26873 | |--IDENT -> testLambdaFalseForceStrictCondition [2309:16]
26874 | |--LPAREN -> ( [2309:51]
26875 | |--PARAMETERS -> PARAMETERS [2309:52]
26876 | |--RPAREN -> ) [2309:52]
26877 | |--LITERAL_THROWS -> throws [2309:54]
26878 | | `--IDENT -> Exception [2309:61]
26879 | `--SLIST -> { [2309:71]
26880 | |--VARIABLE_DEF -> VARIABLE_DEF [2310:8]
26881 | | |--MODIFIERS -> MODIFIERS [2310:8]
26882 | | | `--FINAL -> final [2310:8]
26883 | | |--TYPE -> TYPE [2310:14]
26884 | | | `--IDENT -> DefaultConfiguration [2310:14]
26885 | | |--IDENT -> checkConfig [2310:35]
26886 | | `--ASSIGN -> = [2310:47]
26887 | | `--EXPR -> EXPR [2310:67]
26888 | | `--METHOD_CALL -> ( [2310:67]
26889 | | |--IDENT -> createModuleConfig [2310:49]
26890 | | |--ELIST -> ELIST [2310:84]
26891 | | | `--EXPR -> EXPR [2310:84]
26892 | | | `--DOT -> . [2310:84]
26893 | | | |--IDENT -> IndentationCheck [2310:68]
26894 | | | `--LITERAL_CLASS -> class [2310:85]
26895 | | `--RPAREN -> ) [2310:90]
26896 | |--SEMI -> ; [2310:91]
26897 | |--EXPR -> EXPR [2311:32]
26898 | | `--METHOD_CALL -> ( [2311:32]
26899 | | |--DOT -> . [2311:19]
26900 | | | |--IDENT -> checkConfig [2311:8]
26901 | | | `--IDENT -> addAttribute [2311:20]
26902 | | |--ELIST -> ELIST [2311:33]
26903 | | | |--EXPR -> EXPR [2311:33]
26904 | | | | `--STRING_LITERAL -> "tabWidth" [2311:33]
26905 | | | |--COMMA -> , [2311:43]
26906 | | | `--EXPR -> EXPR [2311:45]
26907 | | | `--STRING_LITERAL -> "4" [2311:45]
26908 | | `--RPAREN -> ) [2311:48]
26909 | |--SEMI -> ; [2311:49]
26910 | |--EXPR -> EXPR [2312:32]
26911 | | `--METHOD_CALL -> ( [2312:32]
26912 | | |--DOT -> . [2312:19]
26913 | | | |--IDENT -> checkConfig [2312:8]
26914 | | | `--IDENT -> addAttribute [2312:20]
26915 | | |--ELIST -> ELIST [2312:33]
26916 | | | |--EXPR -> EXPR [2312:33]
26917 | | | | `--STRING_LITERAL -> "basicOffset" [2312:33]
26918 | | | |--COMMA -> , [2312:46]
26919 | | | `--EXPR -> EXPR [2312:48]
26920 | | | `--STRING_LITERAL -> "4" [2312:48]
26921 | | `--RPAREN -> ) [2312:51]
26922 | |--SEMI -> ; [2312:52]
26923 | |--EXPR -> EXPR [2313:32]
26924 | | `--METHOD_CALL -> ( [2313:32]
26925 | | |--DOT -> . [2313:19]
26926 | | | |--IDENT -> checkConfig [2313:8]
26927 | | | `--IDENT -> addAttribute [2313:20]
26928 | | |--ELIST -> ELIST [2313:33]
26929 | | | |--EXPR -> EXPR [2313:33]
26930 | | | | `--STRING_LITERAL -> "braceAdjustment" [2313:33]
26931 | | | |--COMMA -> , [2313:50]
26932 | | | `--EXPR -> EXPR [2313:52]
26933 | | | `--STRING_LITERAL -> "0" [2313:52]
26934 | | `--RPAREN -> ) [2313:55]
26935 | |--SEMI -> ; [2313:56]
26936 | |--EXPR -> EXPR [2314:32]
26937 | | `--METHOD_CALL -> ( [2314:32]
26938 | | |--DOT -> . [2314:19]
26939 | | | |--IDENT -> checkConfig [2314:8]
26940 | | | `--IDENT -> addAttribute [2314:20]
26941 | | |--ELIST -> ELIST [2314:33]
26942 | | | |--EXPR -> EXPR [2314:33]
26943 | | | | `--STRING_LITERAL -> "forceStrictCondition" [2314:33]
26944 | | | |--COMMA -> , [2314:55]
26945 | | | `--EXPR -> EXPR [2314:57]
26946 | | | `--STRING_LITERAL -> "false" [2314:57]
26947 | | `--RPAREN -> ) [2314:64]
26948 | |--SEMI -> ; [2314:65]
26949 | |--EXPR -> EXPR [2315:32]
26950 | | `--METHOD_CALL -> ( [2315:32]
26951 | | |--DOT -> . [2315:19]
26952 | | | |--IDENT -> checkConfig [2315:8]
26953 | | | `--IDENT -> addAttribute [2315:20]
26954 | | |--ELIST -> ELIST [2315:33]
26955 | | | |--EXPR -> EXPR [2315:33]
26956 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2315:33]
26957 | | | |--COMMA -> , [2315:58]
26958 | | | `--EXPR -> EXPR [2315:60]
26959 | | | `--STRING_LITERAL -> "0" [2315:60]
26960 | | `--RPAREN -> ) [2315:63]
26961 | |--SEMI -> ; [2315:64]
26962 | |--VARIABLE_DEF -> VARIABLE_DEF [2316:8]
26963 | | |--MODIFIERS -> MODIFIERS [2316:8]
26964 | | | `--FINAL -> final [2316:8]
26965 | | |--TYPE -> TYPE [2316:20]
26966 | | | `--ARRAY_DECLARATOR -> [ [2316:20]
26967 | | | |--IDENT -> String [2316:14]
26968 | | | `--RBRACK -> ] [2316:21]
26969 | | |--IDENT -> expected [2316:23]
26970 | | `--ASSIGN -> = [2316:32]
26971 | | `--ARRAY_INIT -> { [2316:34]
26972 | | |--EXPR -> EXPR [2317:21]
26973 | | | `--PLUS -> + [2317:21]
26974 | | | |--STRING_LITERAL -> "34:5: " [2317:12]
26975 | | | `--METHOD_CALL -> ( [2317:38]
26976 | | | |--IDENT -> getCheckMessage [2317:23]
26977 | | | |--ELIST -> ELIST [2317:39]
26978 | | | | |--EXPR -> EXPR [2317:39]
26979 | | | | | `--IDENT -> MSG_ERROR [2317:39]
26980 | | | | |--COMMA -> , [2317:48]
26981 | | | | |--EXPR -> EXPR [2317:50]
26982 | | | | | `--STRING_LITERAL -> "(" [2317:50]
26983 | | | | |--COMMA -> , [2317:53]
26984 | | | | |--EXPR -> EXPR [2317:55]
26985 | | | | | `--NUM_INT -> 4 [2317:55]
26986 | | | | |--COMMA -> , [2317:56]
26987 | | | | `--EXPR -> EXPR [2317:58]
26988 | | | | `--NUM_INT -> 8 [2317:58]
26989 | | | `--RPAREN -> ) [2317:59]
26990 | | |--COMMA -> , [2317:60]
26991 | | |--EXPR -> EXPR [2318:21]
26992 | | | `--PLUS -> + [2318:21]
26993 | | | |--STRING_LITERAL -> "35:5: " [2318:12]
26994 | | | `--METHOD_CALL -> ( [2318:38]
26995 | | | |--IDENT -> getCheckMessage [2318:23]
26996 | | | |--ELIST -> ELIST [2318:39]
26997 | | | | |--EXPR -> EXPR [2318:39]
26998 | | | | | `--IDENT -> MSG_CHILD_ERROR [2318:39]
26999 | | | | |--COMMA -> , [2318:54]
27000 | | | | |--EXPR -> EXPR [2318:56]
27001 | | | | | `--STRING_LITERAL -> "method call" [2318:56]
27002 | | | | |--COMMA -> , [2318:69]
27003 | | | | |--EXPR -> EXPR [2318:71]
27004 | | | | | `--NUM_INT -> 4 [2318:71]
27005 | | | | |--COMMA -> , [2318:72]
27006 | | | | `--EXPR -> EXPR [2318:74]
27007 | | | | `--NUM_INT -> 12 [2318:74]
27008 | | | `--RPAREN -> ) [2318:76]
27009 | | |--COMMA -> , [2318:77]
27010 | | |--EXPR -> EXPR [2319:21]
27011 | | | `--PLUS -> + [2319:21]
27012 | | | |--STRING_LITERAL -> "36:5: " [2319:12]
27013 | | | `--METHOD_CALL -> ( [2319:38]
27014 | | | |--IDENT -> getCheckMessage [2319:23]
27015 | | | |--ELIST -> ELIST [2319:39]
27016 | | | | |--EXPR -> EXPR [2319:39]
27017 | | | | | `--IDENT -> MSG_ERROR [2319:39]
27018 | | | | |--COMMA -> , [2319:48]
27019 | | | | |--EXPR -> EXPR [2319:50]
27020 | | | | | `--STRING_LITERAL -> "(" [2319:50]
27021 | | | | |--COMMA -> , [2319:53]
27022 | | | | |--EXPR -> EXPR [2319:55]
27023 | | | | | `--NUM_INT -> 4 [2319:55]
27024 | | | | |--COMMA -> , [2319:56]
27025 | | | | `--EXPR -> EXPR [2319:58]
27026 | | | | `--NUM_INT -> 8 [2319:58]
27027 | | | `--RPAREN -> ) [2319:59]
27028 | | |--COMMA -> , [2319:60]
27029 | | |--EXPR -> EXPR [2320:21]
27030 | | | `--PLUS -> + [2320:21]
27031 | | | |--STRING_LITERAL -> "47:5: " [2320:12]
27032 | | | `--METHOD_CALL -> ( [2320:38]
27033 | | | |--IDENT -> getCheckMessage [2320:23]
27034 | | | |--ELIST -> ELIST [2320:39]
27035 | | | | |--EXPR -> EXPR [2320:39]
27036 | | | | | `--IDENT -> MSG_ERROR_MULTI [2320:39]
27037 | | | | |--COMMA -> , [2320:54]
27038 | | | | |--EXPR -> EXPR [2320:56]
27039 | | | | | `--STRING_LITERAL -> "block rcurly" [2320:56]
27040 | | | | |--COMMA -> , [2320:70]
27041 | | | | |--EXPR -> EXPR [2320:72]
27042 | | | | | `--NUM_INT -> 4 [2320:72]
27043 | | | | |--COMMA -> , [2320:73]
27044 | | | | `--EXPR -> EXPR [2320:75]
27045 | | | | `--STRING_LITERAL -> "8, 16" [2320:75]
27046 | | | `--RPAREN -> ) [2320:82]
27047 | | |--COMMA -> , [2320:83]
27048 | | |--EXPR -> EXPR [2321:21]
27049 | | | `--PLUS -> + [2321:21]
27050 | | | |--STRING_LITERAL -> "73:5: " [2321:12]
27051 | | | `--METHOD_CALL -> ( [2321:38]
27052 | | | |--IDENT -> getCheckMessage [2321:23]
27053 | | | |--ELIST -> ELIST [2321:39]
27054 | | | | |--EXPR -> EXPR [2321:39]
27055 | | | | | `--IDENT -> MSG_ERROR [2321:39]
27056 | | | | |--COMMA -> , [2321:48]
27057 | | | | |--EXPR -> EXPR [2321:50]
27058 | | | | | `--STRING_LITERAL -> "->" [2321:50]
27059 | | | | |--COMMA -> , [2321:54]
27060 | | | | |--EXPR -> EXPR [2321:56]
27061 | | | | | `--NUM_INT -> 4 [2321:56]
27062 | | | | |--COMMA -> , [2321:57]
27063 | | | | `--EXPR -> EXPR [2321:59]
27064 | | | | `--NUM_INT -> 8 [2321:59]
27065 | | | `--RPAREN -> ) [2321:60]
27066 | | |--COMMA -> , [2321:61]
27067 | | `--RCURLY -> } [2322:8]
27068 | |--SEMI -> ; [2322:9]
27069 | |--EXPR -> EXPR [2324:19]
27070 | | `--METHOD_CALL -> ( [2324:19]
27071 | | |--IDENT -> verifyWarns [2324:8]
27072 | | |--ELIST -> ELIST [2324:20]
27073 | | | |--EXPR -> EXPR [2324:20]
27074 | | | | `--IDENT -> checkConfig [2324:20]
27075 | | | |--COMMA -> , [2324:31]
27076 | | | |--EXPR -> EXPR [2324:40]
27077 | | | | `--METHOD_CALL -> ( [2324:40]
27078 | | | | |--IDENT -> getPath [2324:33]
27079 | | | | |--ELIST -> ELIST [2324:41]
27080 | | | | | `--EXPR -> EXPR [2324:41]
27081 | | | | | `--STRING_LITERAL -> "InputIndentationLambda6.java" [2324:41]
27082 | | | | `--RPAREN -> ) [2324:71]
27083 | | | |--COMMA -> , [2324:72]
27084 | | | `--EXPR -> EXPR [2324:74]
27085 | | | `--IDENT -> expected [2324:74]
27086 | | `--RPAREN -> ) [2324:82]
27087 | |--SEMI -> ; [2324:83]
27088 | `--RCURLY -> } [2325:4]
27089 |--METHOD_DEF -> METHOD_DEF [2327:4]
27090 | |--MODIFIERS -> MODIFIERS [2327:4]
27091 | | |--ANNOTATION -> ANNOTATION [2327:4]
27092 | | | |--AT -> @ [2327:4]
27093 | | | `--IDENT -> Test [2327:5]
27094 | | `--LITERAL_PUBLIC -> public [2328:4]
27095 | |--TYPE -> TYPE [2328:11]
27096 | | `--LITERAL_VOID -> void [2328:11]
27097 | |--IDENT -> testLambdaTrueForceStrictCondition [2328:16]
27098 | |--LPAREN -> ( [2328:50]
27099 | |--PARAMETERS -> PARAMETERS [2328:51]
27100 | |--RPAREN -> ) [2328:51]
27101 | |--LITERAL_THROWS -> throws [2328:53]
27102 | | `--IDENT -> Exception [2328:60]
27103 | `--SLIST -> { [2328:70]
27104 | |--VARIABLE_DEF -> VARIABLE_DEF [2329:8]
27105 | | |--MODIFIERS -> MODIFIERS [2329:8]
27106 | | | `--FINAL -> final [2329:8]
27107 | | |--TYPE -> TYPE [2329:14]
27108 | | | `--IDENT -> DefaultConfiguration [2329:14]
27109 | | |--IDENT -> checkConfig [2329:35]
27110 | | `--ASSIGN -> = [2329:47]
27111 | | `--EXPR -> EXPR [2329:67]
27112 | | `--METHOD_CALL -> ( [2329:67]
27113 | | |--IDENT -> createModuleConfig [2329:49]
27114 | | |--ELIST -> ELIST [2329:84]
27115 | | | `--EXPR -> EXPR [2329:84]
27116 | | | `--DOT -> . [2329:84]
27117 | | | |--IDENT -> IndentationCheck [2329:68]
27118 | | | `--LITERAL_CLASS -> class [2329:85]
27119 | | `--RPAREN -> ) [2329:90]
27120 | |--SEMI -> ; [2329:91]
27121 | |--EXPR -> EXPR [2330:32]
27122 | | `--METHOD_CALL -> ( [2330:32]
27123 | | |--DOT -> . [2330:19]
27124 | | | |--IDENT -> checkConfig [2330:8]
27125 | | | `--IDENT -> addAttribute [2330:20]
27126 | | |--ELIST -> ELIST [2330:33]
27127 | | | |--EXPR -> EXPR [2330:33]
27128 | | | | `--STRING_LITERAL -> "tabWidth" [2330:33]
27129 | | | |--COMMA -> , [2330:43]
27130 | | | `--EXPR -> EXPR [2330:45]
27131 | | | `--STRING_LITERAL -> "4" [2330:45]
27132 | | `--RPAREN -> ) [2330:48]
27133 | |--SEMI -> ; [2330:49]
27134 | |--EXPR -> EXPR [2331:32]
27135 | | `--METHOD_CALL -> ( [2331:32]
27136 | | |--DOT -> . [2331:19]
27137 | | | |--IDENT -> checkConfig [2331:8]
27138 | | | `--IDENT -> addAttribute [2331:20]
27139 | | |--ELIST -> ELIST [2331:33]
27140 | | | |--EXPR -> EXPR [2331:33]
27141 | | | | `--STRING_LITERAL -> "basicOffset" [2331:33]
27142 | | | |--COMMA -> , [2331:46]
27143 | | | `--EXPR -> EXPR [2331:48]
27144 | | | `--STRING_LITERAL -> "4" [2331:48]
27145 | | `--RPAREN -> ) [2331:51]
27146 | |--SEMI -> ; [2331:52]
27147 | |--EXPR -> EXPR [2332:32]
27148 | | `--METHOD_CALL -> ( [2332:32]
27149 | | |--DOT -> . [2332:19]
27150 | | | |--IDENT -> checkConfig [2332:8]
27151 | | | `--IDENT -> addAttribute [2332:20]
27152 | | |--ELIST -> ELIST [2332:33]
27153 | | | |--EXPR -> EXPR [2332:33]
27154 | | | | `--STRING_LITERAL -> "braceAdjustment" [2332:33]
27155 | | | |--COMMA -> , [2332:50]
27156 | | | `--EXPR -> EXPR [2332:52]
27157 | | | `--STRING_LITERAL -> "0" [2332:52]
27158 | | `--RPAREN -> ) [2332:55]
27159 | |--SEMI -> ; [2332:56]
27160 | |--EXPR -> EXPR [2333:32]
27161 | | `--METHOD_CALL -> ( [2333:32]
27162 | | |--DOT -> . [2333:19]
27163 | | | |--IDENT -> checkConfig [2333:8]
27164 | | | `--IDENT -> addAttribute [2333:20]
27165 | | |--ELIST -> ELIST [2333:33]
27166 | | | |--EXPR -> EXPR [2333:33]
27167 | | | | `--STRING_LITERAL -> "forceStrictCondition" [2333:33]
27168 | | | |--COMMA -> , [2333:55]
27169 | | | `--EXPR -> EXPR [2333:57]
27170 | | | `--STRING_LITERAL -> "true" [2333:57]
27171 | | `--RPAREN -> ) [2333:63]
27172 | |--SEMI -> ; [2333:64]
27173 | |--EXPR -> EXPR [2334:32]
27174 | | `--METHOD_CALL -> ( [2334:32]
27175 | | |--DOT -> . [2334:19]
27176 | | | |--IDENT -> checkConfig [2334:8]
27177 | | | `--IDENT -> addAttribute [2334:20]
27178 | | |--ELIST -> ELIST [2334:33]
27179 | | | |--EXPR -> EXPR [2334:33]
27180 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2334:33]
27181 | | | |--COMMA -> , [2334:58]
27182 | | | `--EXPR -> EXPR [2334:60]
27183 | | | `--STRING_LITERAL -> "4" [2334:60]
27184 | | `--RPAREN -> ) [2334:63]
27185 | |--SEMI -> ; [2334:64]
27186 | |--VARIABLE_DEF -> VARIABLE_DEF [2335:8]
27187 | | |--MODIFIERS -> MODIFIERS [2335:8]
27188 | | | `--FINAL -> final [2335:8]
27189 | | |--TYPE -> TYPE [2335:20]
27190 | | | `--ARRAY_DECLARATOR -> [ [2335:20]
27191 | | | |--IDENT -> String [2335:14]
27192 | | | `--RBRACK -> ] [2335:21]
27193 | | |--IDENT -> expected [2335:23]
27194 | | `--ASSIGN -> = [2335:32]
27195 | | `--ARRAY_INIT -> { [2335:34]
27196 | | |--EXPR -> EXPR [2336:22]
27197 | | | `--PLUS -> + [2336:22]
27198 | | | |--STRING_LITERAL -> "23:17: " [2336:12]
27199 | | | `--METHOD_CALL -> ( [2336:39]
27200 | | | |--IDENT -> getCheckMessage [2336:24]
27201 | | | |--ELIST -> ELIST [2336:40]
27202 | | | | |--EXPR -> EXPR [2336:40]
27203 | | | | | `--IDENT -> MSG_ERROR [2336:40]
27204 | | | | |--COMMA -> , [2336:49]
27205 | | | | |--EXPR -> EXPR [2336:51]
27206 | | | | | `--STRING_LITERAL -> "(" [2336:51]
27207 | | | | |--COMMA -> , [2336:54]
27208 | | | | |--EXPR -> EXPR [2336:56]
27209 | | | | | `--NUM_INT -> 16 [2336:56]
27210 | | | | |--COMMA -> , [2336:58]
27211 | | | | `--EXPR -> EXPR [2336:60]
27212 | | | | `--NUM_INT -> 12 [2336:60]
27213 | | | `--RPAREN -> ) [2336:62]
27214 | | |--COMMA -> , [2336:63]
27215 | | |--EXPR -> EXPR [2337:22]
27216 | | | `--PLUS -> + [2337:22]
27217 | | | |--STRING_LITERAL -> "24:17: " [2337:12]
27218 | | | `--METHOD_CALL -> ( [2337:39]
27219 | | | |--IDENT -> getCheckMessage [2337:24]
27220 | | | |--ELIST -> ELIST [2337:40]
27221 | | | | |--EXPR -> EXPR [2337:40]
27222 | | | | | `--IDENT -> MSG_ERROR [2337:40]
27223 | | | | |--COMMA -> , [2337:49]
27224 | | | | |--EXPR -> EXPR [2337:51]
27225 | | | | | `--STRING_LITERAL -> "->" [2337:51]
27226 | | | | |--COMMA -> , [2337:55]
27227 | | | | |--EXPR -> EXPR [2337:57]
27228 | | | | | `--NUM_INT -> 16 [2337:57]
27229 | | | | |--COMMA -> , [2337:59]
27230 | | | | `--EXPR -> EXPR [2337:61]
27231 | | | | `--NUM_INT -> 12 [2337:61]
27232 | | | `--RPAREN -> ) [2337:63]
27233 | | |--COMMA -> , [2337:64]
27234 | | |--EXPR -> EXPR [2338:22]
27235 | | | `--PLUS -> + [2338:22]
27236 | | | |--STRING_LITERAL -> "26:27: " [2338:12]
27237 | | | `--METHOD_CALL -> ( [2338:39]
27238 | | | |--IDENT -> getCheckMessage [2338:24]
27239 | | | |--ELIST -> ELIST [2338:40]
27240 | | | | |--EXPR -> EXPR [2338:40]
27241 | | | | | `--IDENT -> MSG_ERROR [2338:40]
27242 | | | | |--COMMA -> , [2338:49]
27243 | | | | |--EXPR -> EXPR [2338:51]
27244 | | | | | `--STRING_LITERAL -> "\"SECOND_ARG\"" [2338:51]
27245 | | | | |--COMMA -> , [2338:67]
27246 | | | | |--EXPR -> EXPR [2338:69]
27247 | | | | | `--NUM_INT -> 26 [2338:69]
27248 | | | | |--COMMA -> , [2338:71]
27249 | | | | `--EXPR -> EXPR [2338:73]
27250 | | | | `--NUM_INT -> 12 [2338:73]
27251 | | | `--RPAREN -> ) [2338:75]
27252 | | |--COMMA -> , [2338:76]
27253 | | |--EXPR -> EXPR [2339:22]
27254 | | | `--PLUS -> + [2339:22]
27255 | | | |--STRING_LITERAL -> "27:26: " [2339:12]
27256 | | | `--METHOD_CALL -> ( [2339:39]
27257 | | | |--IDENT -> getCheckMessage [2339:24]
27258 | | | |--ELIST -> ELIST [2339:40]
27259 | | | | |--EXPR -> EXPR [2339:40]
27260 | | | | | `--IDENT -> MSG_ERROR [2339:40]
27261 | | | | |--COMMA -> , [2339:49]
27262 | | | | |--EXPR -> EXPR [2339:51]
27263 | | | | | `--STRING_LITERAL -> "(" [2339:51]
27264 | | | | |--COMMA -> , [2339:54]
27265 | | | | |--EXPR -> EXPR [2339:56]
27266 | | | | | `--NUM_INT -> 25 [2339:56]
27267 | | | | |--COMMA -> , [2339:58]
27268 | | | | `--EXPR -> EXPR [2339:60]
27269 | | | | `--NUM_INT -> 12 [2339:60]
27270 | | | `--RPAREN -> ) [2339:62]
27271 | | |--COMMA -> , [2339:63]
27272 | | |--EXPR -> EXPR [2340:22]
27273 | | | `--PLUS -> + [2340:22]
27274 | | | |--STRING_LITERAL -> "30:17: " [2340:12]
27275 | | | `--METHOD_CALL -> ( [2340:39]
27276 | | | |--IDENT -> getCheckMessage [2340:24]
27277 | | | |--ELIST -> ELIST [2340:40]
27278 | | | | |--EXPR -> EXPR [2340:40]
27279 | | | | | `--IDENT -> MSG_ERROR [2340:40]
27280 | | | | |--COMMA -> , [2340:49]
27281 | | | | |--EXPR -> EXPR [2340:51]
27282 | | | | | `--STRING_LITERAL -> "(" [2340:51]
27283 | | | | |--COMMA -> , [2340:54]
27284 | | | | |--EXPR -> EXPR [2340:56]
27285 | | | | | `--NUM_INT -> 16 [2340:56]
27286 | | | | |--COMMA -> , [2340:58]
27287 | | | | `--EXPR -> EXPR [2340:60]
27288 | | | | `--NUM_INT -> 12 [2340:60]
27289 | | | `--RPAREN -> ) [2340:62]
27290 | | |--COMMA -> , [2340:63]
27291 | | |--EXPR -> EXPR [2341:22]
27292 | | | `--PLUS -> + [2341:22]
27293 | | | |--STRING_LITERAL -> "31:21: " [2341:12]
27294 | | | `--METHOD_CALL -> ( [2341:39]
27295 | | | |--IDENT -> getCheckMessage [2341:24]
27296 | | | |--ELIST -> ELIST [2341:40]
27297 | | | | |--EXPR -> EXPR [2341:40]
27298 | | | | | `--IDENT -> MSG_ERROR [2341:40]
27299 | | | | |--COMMA -> , [2341:49]
27300 | | | | |--EXPR -> EXPR [2341:51]
27301 | | | | | `--STRING_LITERAL -> "if" [2341:51]
27302 | | | | |--COMMA -> , [2341:55]
27303 | | | | |--EXPR -> EXPR [2341:57]
27304 | | | | | `--NUM_INT -> 20 [2341:57]
27305 | | | | |--COMMA -> , [2341:59]
27306 | | | | `--EXPR -> EXPR [2341:61]
27307 | | | | `--NUM_INT -> 16 [2341:61]
27308 | | | `--RPAREN -> ) [2341:63]
27309 | | |--COMMA -> , [2341:64]
27310 | | |--EXPR -> EXPR [2342:22]
27311 | | | `--PLUS -> + [2342:22]
27312 | | | |--STRING_LITERAL -> "32:25: " [2342:12]
27313 | | | `--METHOD_CALL -> ( [2342:39]
27314 | | | |--IDENT -> getCheckMessage [2342:24]
27315 | | | |--ELIST -> ELIST [2342:40]
27316 | | | | |--EXPR -> EXPR [2342:40]
27317 | | | | | `--IDENT -> MSG_CHILD_ERROR [2342:40]
27318 | | | | |--COMMA -> , [2342:55]
27319 | | | | |--EXPR -> EXPR [2342:57]
27320 | | | | | `--STRING_LITERAL -> "if" [2342:57]
27321 | | | | |--COMMA -> , [2342:61]
27322 | | | | |--EXPR -> EXPR [2342:63]
27323 | | | | | `--NUM_INT -> 24 [2342:63]
27324 | | | | |--COMMA -> , [2342:65]
27325 | | | | `--EXPR -> EXPR [2342:67]
27326 | | | | `--NUM_INT -> 20 [2342:67]
27327 | | | `--RPAREN -> ) [2342:69]
27328 | | |--COMMA -> , [2342:70]
27329 | | |--EXPR -> EXPR [2343:22]
27330 | | | `--PLUS -> + [2343:22]
27331 | | | |--STRING_LITERAL -> "33:21: " [2343:12]
27332 | | | `--METHOD_CALL -> ( [2343:39]
27333 | | | |--IDENT -> getCheckMessage [2343:24]
27334 | | | |--ELIST -> ELIST [2343:40]
27335 | | | | |--EXPR -> EXPR [2343:40]
27336 | | | | | `--IDENT -> MSG_ERROR [2343:40]
27337 | | | | |--COMMA -> , [2343:49]
27338 | | | | |--EXPR -> EXPR [2343:51]
27339 | | | | | `--STRING_LITERAL -> "if rcurly" [2343:51]
27340 | | | | |--COMMA -> , [2343:62]
27341 | | | | |--EXPR -> EXPR [2343:64]
27342 | | | | | `--NUM_INT -> 20 [2343:64]
27343 | | | | |--COMMA -> , [2343:66]
27344 | | | | `--EXPR -> EXPR [2343:68]
27345 | | | | `--NUM_INT -> 16 [2343:68]
27346 | | | `--RPAREN -> ) [2343:70]
27347 | | |--COMMA -> , [2343:71]
27348 | | |--EXPR -> EXPR [2344:22]
27349 | | | `--PLUS -> + [2344:22]
27350 | | | |--STRING_LITERAL -> "34:25: " [2344:12]
27351 | | | `--METHOD_CALL -> ( [2344:39]
27352 | | | |--IDENT -> getCheckMessage [2344:24]
27353 | | | |--ELIST -> ELIST [2344:40]
27354 | | | | |--EXPR -> EXPR [2344:40]
27355 | | | | | `--IDENT -> MSG_CHILD_ERROR [2344:40]
27356 | | | | |--COMMA -> , [2344:55]
27357 | | | | |--EXPR -> EXPR [2344:57]
27358 | | | | | `--STRING_LITERAL -> "else" [2344:57]
27359 | | | | |--COMMA -> , [2344:63]
27360 | | | | |--EXPR -> EXPR [2344:65]
27361 | | | | | `--NUM_INT -> 24 [2344:65]
27362 | | | | |--COMMA -> , [2344:67]
27363 | | | | `--EXPR -> EXPR [2344:69]
27364 | | | | `--NUM_INT -> 20 [2344:69]
27365 | | | `--RPAREN -> ) [2344:71]
27366 | | |--COMMA -> , [2344:72]
27367 | | |--EXPR -> EXPR [2345:22]
27368 | | | `--PLUS -> + [2345:22]
27369 | | | |--STRING_LITERAL -> "35:21: " [2345:12]
27370 | | | `--METHOD_CALL -> ( [2345:39]
27371 | | | |--IDENT -> getCheckMessage [2345:24]
27372 | | | |--ELIST -> ELIST [2345:40]
27373 | | | | |--EXPR -> EXPR [2345:40]
27374 | | | | | `--IDENT -> MSG_ERROR [2345:40]
27375 | | | | |--COMMA -> , [2345:49]
27376 | | | | |--EXPR -> EXPR [2345:51]
27377 | | | | | `--STRING_LITERAL -> "else rcurly" [2345:51]
27378 | | | | |--COMMA -> , [2345:64]
27379 | | | | |--EXPR -> EXPR [2345:66]
27380 | | | | | `--NUM_INT -> 20 [2345:66]
27381 | | | | |--COMMA -> , [2345:68]
27382 | | | | `--EXPR -> EXPR [2345:70]
27383 | | | | `--NUM_INT -> 16 [2345:70]
27384 | | | `--RPAREN -> ) [2345:72]
27385 | | |--COMMA -> , [2345:73]
27386 | | |--EXPR -> EXPR [2346:22]
27387 | | | `--PLUS -> + [2346:22]
27388 | | | |--STRING_LITERAL -> "36:17: " [2346:12]
27389 | | | `--METHOD_CALL -> ( [2346:39]
27390 | | | |--IDENT -> getCheckMessage [2346:24]
27391 | | | |--ELIST -> ELIST [2346:40]
27392 | | | | |--EXPR -> EXPR [2346:40]
27393 | | | | | `--IDENT -> MSG_ERROR [2346:40]
27394 | | | | |--COMMA -> , [2346:49]
27395 | | | | |--EXPR -> EXPR [2346:51]
27396 | | | | | `--STRING_LITERAL -> "block rcurly" [2346:51]
27397 | | | | |--COMMA -> , [2346:65]
27398 | | | | |--EXPR -> EXPR [2346:67]
27399 | | | | | `--NUM_INT -> 16 [2346:67]
27400 | | | | |--COMMA -> , [2346:69]
27401 | | | | `--EXPR -> EXPR [2346:71]
27402 | | | | `--NUM_INT -> 12 [2346:71]
27403 | | | `--RPAREN -> ) [2346:73]
27404 | | |--COMMA -> , [2346:74]
27405 | | |--EXPR -> EXPR [2347:22]
27406 | | | `--PLUS -> + [2347:22]
27407 | | | |--STRING_LITERAL -> "39:17: " [2347:12]
27408 | | | `--METHOD_CALL -> ( [2347:39]
27409 | | | |--IDENT -> getCheckMessage [2347:24]
27410 | | | |--ELIST -> ELIST [2347:40]
27411 | | | | |--EXPR -> EXPR [2347:40]
27412 | | | | | `--IDENT -> MSG_ERROR [2347:40]
27413 | | | | |--COMMA -> , [2347:49]
27414 | | | | |--EXPR -> EXPR [2347:51]
27415 | | | | | `--STRING_LITERAL -> "(" [2347:51]
27416 | | | | |--COMMA -> , [2347:54]
27417 | | | | |--EXPR -> EXPR [2347:56]
27418 | | | | | `--NUM_INT -> 16 [2347:56]
27419 | | | | |--COMMA -> , [2347:58]
27420 | | | | `--EXPR -> EXPR [2347:60]
27421 | | | | `--NUM_INT -> 12 [2347:60]
27422 | | | `--RPAREN -> ) [2347:62]
27423 | | |--COMMA -> , [2347:63]
27424 | | |--EXPR -> EXPR [2348:22]
27425 | | | `--PLUS -> + [2348:22]
27426 | | | |--STRING_LITERAL -> "40:17: " [2348:12]
27427 | | | `--METHOD_CALL -> ( [2348:39]
27428 | | | |--IDENT -> getCheckMessage [2348:24]
27429 | | | |--ELIST -> ELIST [2348:40]
27430 | | | | |--EXPR -> EXPR [2348:40]
27431 | | | | | `--IDENT -> MSG_ERROR [2348:40]
27432 | | | | |--COMMA -> , [2348:49]
27433 | | | | |--EXPR -> EXPR [2348:51]
27434 | | | | | `--STRING_LITERAL -> "->" [2348:51]
27435 | | | | |--COMMA -> , [2348:55]
27436 | | | | |--EXPR -> EXPR [2348:57]
27437 | | | | | `--NUM_INT -> 16 [2348:57]
27438 | | | | |--COMMA -> , [2348:59]
27439 | | | | `--EXPR -> EXPR [2348:61]
27440 | | | | `--NUM_INT -> 12 [2348:61]
27441 | | | `--RPAREN -> ) [2348:63]
27442 | | |--COMMA -> , [2348:64]
27443 | | |--EXPR -> EXPR [2349:22]
27444 | | | `--PLUS -> + [2349:22]
27445 | | | |--STRING_LITERAL -> "41:21: " [2349:12]
27446 | | | `--METHOD_CALL -> ( [2349:39]
27447 | | | |--IDENT -> getCheckMessage [2349:24]
27448 | | | |--ELIST -> ELIST [2349:40]
27449 | | | | |--EXPR -> EXPR [2349:40]
27450 | | | | | `--IDENT -> MSG_ERROR [2349:40]
27451 | | | | |--COMMA -> , [2349:49]
27452 | | | | |--EXPR -> EXPR [2349:51]
27453 | | | | | `--STRING_LITERAL -> "if" [2349:51]
27454 | | | | |--COMMA -> , [2349:55]
27455 | | | | |--EXPR -> EXPR [2349:57]
27456 | | | | | `--NUM_INT -> 20 [2349:57]
27457 | | | | |--COMMA -> , [2349:59]
27458 | | | | `--EXPR -> EXPR [2349:61]
27459 | | | | `--NUM_INT -> 16 [2349:61]
27460 | | | `--RPAREN -> ) [2349:63]
27461 | | |--COMMA -> , [2349:64]
27462 | | |--EXPR -> EXPR [2350:21]
27463 | | | `--PLUS -> + [2350:21]
27464 | | | |--STRING_LITERAL -> "44:1: " [2350:12]
27465 | | | `--METHOD_CALL -> ( [2350:38]
27466 | | | |--IDENT -> getCheckMessage [2350:23]
27467 | | | |--ELIST -> ELIST [2350:39]
27468 | | | | |--EXPR -> EXPR [2350:39]
27469 | | | | | `--IDENT -> MSG_ERROR [2350:39]
27470 | | | | |--COMMA -> , [2350:48]
27471 | | | | |--EXPR -> EXPR [2350:50]
27472 | | | | | `--STRING_LITERAL -> "block rcurly" [2350:50]
27473 | | | | |--COMMA -> , [2350:64]
27474 | | | | |--EXPR -> EXPR [2350:66]
27475 | | | | | `--NUM_INT -> 0 [2350:66]
27476 | | | | |--COMMA -> , [2350:67]
27477 | | | | `--EXPR -> EXPR [2350:69]
27478 | | | | `--NUM_INT -> 12 [2350:69]
27479 | | | `--RPAREN -> ) [2350:71]
27480 | | |--COMMA -> , [2350:72]
27481 | | `--RCURLY -> } [2351:8]
27482 | |--SEMI -> ; [2351:9]
27483 | |--EXPR -> EXPR [2353:19]
27484 | | `--METHOD_CALL -> ( [2353:19]
27485 | | |--IDENT -> verifyWarns [2353:8]
27486 | | |--ELIST -> ELIST [2353:20]
27487 | | | |--EXPR -> EXPR [2353:20]
27488 | | | | `--IDENT -> checkConfig [2353:20]
27489 | | | |--COMMA -> , [2353:31]
27490 | | | |--EXPR -> EXPR [2353:40]
27491 | | | | `--METHOD_CALL -> ( [2353:40]
27492 | | | | |--IDENT -> getPath [2353:33]
27493 | | | | |--ELIST -> ELIST [2353:41]
27494 | | | | | `--EXPR -> EXPR [2353:41]
27495 | | | | | `--STRING_LITERAL -> "InputIndentationLambda7.java" [2353:41]
27496 | | | | `--RPAREN -> ) [2353:71]
27497 | | | |--COMMA -> , [2353:72]
27498 | | | `--EXPR -> EXPR [2353:74]
27499 | | | `--IDENT -> expected [2353:74]
27500 | | `--RPAREN -> ) [2353:82]
27501 | |--SEMI -> ; [2353:83]
27502 | `--RCURLY -> } [2354:4]
27503 |--METHOD_DEF -> METHOD_DEF [2356:4]
27504 | |--MODIFIERS -> MODIFIERS [2356:4]
27505 | | |--ANNOTATION -> ANNOTATION [2356:4]
27506 | | | |--AT -> @ [2356:4]
27507 | | | `--IDENT -> Test [2356:5]
27508 | | `--LITERAL_PUBLIC -> public [2357:4]
27509 | |--TYPE -> TYPE [2357:11]
27510 | | `--LITERAL_VOID -> void [2357:11]
27511 | |--IDENT -> testLambdaOddConditions [2357:16]
27512 | |--LPAREN -> ( [2357:39]
27513 | |--PARAMETERS -> PARAMETERS [2357:40]
27514 | |--RPAREN -> ) [2357:40]
27515 | |--LITERAL_THROWS -> throws [2357:42]
27516 | | `--IDENT -> Exception [2357:49]
27517 | `--SLIST -> { [2357:59]
27518 | |--VARIABLE_DEF -> VARIABLE_DEF [2358:8]
27519 | | |--MODIFIERS -> MODIFIERS [2358:8]
27520 | | | `--FINAL -> final [2358:8]
27521 | | |--TYPE -> TYPE [2358:14]
27522 | | | `--IDENT -> DefaultConfiguration [2358:14]
27523 | | |--IDENT -> checkConfig [2358:35]
27524 | | `--ASSIGN -> = [2358:47]
27525 | | `--EXPR -> EXPR [2358:67]
27526 | | `--METHOD_CALL -> ( [2358:67]
27527 | | |--IDENT -> createModuleConfig [2358:49]
27528 | | |--ELIST -> ELIST [2358:84]
27529 | | | `--EXPR -> EXPR [2358:84]
27530 | | | `--DOT -> . [2358:84]
27531 | | | |--IDENT -> IndentationCheck [2358:68]
27532 | | | `--LITERAL_CLASS -> class [2358:85]
27533 | | `--RPAREN -> ) [2358:90]
27534 | |--SEMI -> ; [2358:91]
27535 | |--EXPR -> EXPR [2359:32]
27536 | | `--METHOD_CALL -> ( [2359:32]
27537 | | |--DOT -> . [2359:19]
27538 | | | |--IDENT -> checkConfig [2359:8]
27539 | | | `--IDENT -> addAttribute [2359:20]
27540 | | |--ELIST -> ELIST [2359:33]
27541 | | | |--EXPR -> EXPR [2359:33]
27542 | | | | `--STRING_LITERAL -> "tabWidth" [2359:33]
27543 | | | |--COMMA -> , [2359:43]
27544 | | | `--EXPR -> EXPR [2359:45]
27545 | | | `--STRING_LITERAL -> "4" [2359:45]
27546 | | `--RPAREN -> ) [2359:48]
27547 | |--SEMI -> ; [2359:49]
27548 | |--EXPR -> EXPR [2360:32]
27549 | | `--METHOD_CALL -> ( [2360:32]
27550 | | |--DOT -> . [2360:19]
27551 | | | |--IDENT -> checkConfig [2360:8]
27552 | | | `--IDENT -> addAttribute [2360:20]
27553 | | |--ELIST -> ELIST [2360:33]
27554 | | | |--EXPR -> EXPR [2360:33]
27555 | | | | `--STRING_LITERAL -> "basicOffset" [2360:33]
27556 | | | |--COMMA -> , [2360:46]
27557 | | | `--EXPR -> EXPR [2360:48]
27558 | | | `--STRING_LITERAL -> "3" [2360:48]
27559 | | `--RPAREN -> ) [2360:51]
27560 | |--SEMI -> ; [2360:52]
27561 | |--EXPR -> EXPR [2361:32]
27562 | | `--METHOD_CALL -> ( [2361:32]
27563 | | |--DOT -> . [2361:19]
27564 | | | |--IDENT -> checkConfig [2361:8]
27565 | | | `--IDENT -> addAttribute [2361:20]
27566 | | |--ELIST -> ELIST [2361:33]
27567 | | | |--EXPR -> EXPR [2361:33]
27568 | | | | `--STRING_LITERAL -> "braceAdjustment" [2361:33]
27569 | | | |--COMMA -> , [2361:50]
27570 | | | `--EXPR -> EXPR [2361:52]
27571 | | | `--STRING_LITERAL -> "0" [2361:52]
27572 | | `--RPAREN -> ) [2361:55]
27573 | |--SEMI -> ; [2361:56]
27574 | |--EXPR -> EXPR [2362:32]
27575 | | `--METHOD_CALL -> ( [2362:32]
27576 | | |--DOT -> . [2362:19]
27577 | | | |--IDENT -> checkConfig [2362:8]
27578 | | | `--IDENT -> addAttribute [2362:20]
27579 | | |--ELIST -> ELIST [2362:33]
27580 | | | |--EXPR -> EXPR [2362:33]
27581 | | | | `--STRING_LITERAL -> "forceStrictCondition" [2362:33]
27582 | | | |--COMMA -> , [2362:55]
27583 | | | `--EXPR -> EXPR [2362:57]
27584 | | | `--STRING_LITERAL -> "false" [2362:57]
27585 | | `--RPAREN -> ) [2362:64]
27586 | |--SEMI -> ; [2362:65]
27587 | |--EXPR -> EXPR [2363:32]
27588 | | `--METHOD_CALL -> ( [2363:32]
27589 | | |--DOT -> . [2363:19]
27590 | | | |--IDENT -> checkConfig [2363:8]
27591 | | | `--IDENT -> addAttribute [2363:20]
27592 | | |--ELIST -> ELIST [2363:33]
27593 | | | |--EXPR -> EXPR [2363:33]
27594 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2363:33]
27595 | | | |--COMMA -> , [2363:58]
27596 | | | `--EXPR -> EXPR [2363:60]
27597 | | | `--STRING_LITERAL -> "7" [2363:60]
27598 | | `--RPAREN -> ) [2363:63]
27599 | |--SEMI -> ; [2363:64]
27600 | |--VARIABLE_DEF -> VARIABLE_DEF [2364:8]
27601 | | |--MODIFIERS -> MODIFIERS [2364:8]
27602 | | | `--FINAL -> final [2364:8]
27603 | | |--TYPE -> TYPE [2364:20]
27604 | | | `--ARRAY_DECLARATOR -> [ [2364:20]
27605 | | | |--IDENT -> String [2364:14]
27606 | | | `--RBRACK -> ] [2364:21]
27607 | | |--IDENT -> expected [2364:23]
27608 | | `--ASSIGN -> = [2364:32]
27609 | | `--EXPR -> EXPR [2364:44]
27610 | | `--DOT -> . [2364:44]
27611 | | |--IDENT -> CommonUtil [2364:34]
27612 | | `--IDENT -> EMPTY_STRING_ARRAY [2364:45]
27613 | |--SEMI -> ; [2364:63]
27614 | |--EXPR -> EXPR [2366:19]
27615 | | `--METHOD_CALL -> ( [2366:19]
27616 | | |--IDENT -> verifyWarns [2366:8]
27617 | | |--ELIST -> ELIST [2366:20]
27618 | | | |--EXPR -> EXPR [2366:20]
27619 | | | | `--IDENT -> checkConfig [2366:20]
27620 | | | |--COMMA -> , [2366:31]
27621 | | | |--EXPR -> EXPR [2366:40]
27622 | | | | `--METHOD_CALL -> ( [2366:40]
27623 | | | | |--IDENT -> getPath [2366:33]
27624 | | | | |--ELIST -> ELIST [2366:41]
27625 | | | | | `--EXPR -> EXPR [2366:41]
27626 | | | | | `--STRING_LITERAL -> "InputIndentationLambda8.java" [2366:41]
27627 | | | | `--RPAREN -> ) [2366:71]
27628 | | | |--COMMA -> , [2366:72]
27629 | | | `--EXPR -> EXPR [2366:74]
27630 | | | `--IDENT -> expected [2366:74]
27631 | | `--RPAREN -> ) [2366:82]
27632 | |--SEMI -> ; [2366:83]
27633 | `--RCURLY -> } [2367:4]
27634 |--METHOD_DEF -> METHOD_DEF [2369:4]
27635 | |--MODIFIERS -> MODIFIERS [2369:4]
27636 | | |--ANNOTATION -> ANNOTATION [2369:4]
27637 | | | |--AT -> @ [2369:4]
27638 | | | `--IDENT -> Test [2369:5]
27639 | | `--LITERAL_PUBLIC -> public [2370:4]
27640 | |--TYPE -> TYPE [2370:11]
27641 | | `--LITERAL_VOID -> void [2370:11]
27642 | |--IDENT -> testSeparatedStatements [2370:16]
27643 | |--LPAREN -> ( [2370:39]
27644 | |--PARAMETERS -> PARAMETERS [2370:40]
27645 | |--RPAREN -> ) [2370:40]
27646 | |--LITERAL_THROWS -> throws [2370:42]
27647 | | `--IDENT -> Exception [2370:49]
27648 | `--SLIST -> { [2370:59]
27649 | |--VARIABLE_DEF -> VARIABLE_DEF [2371:8]
27650 | | |--MODIFIERS -> MODIFIERS [2371:8]
27651 | | | `--FINAL -> final [2371:8]
27652 | | |--TYPE -> TYPE [2371:14]
27653 | | | `--IDENT -> DefaultConfiguration [2371:14]
27654 | | |--IDENT -> checkConfig [2371:35]
27655 | | `--ASSIGN -> = [2371:47]
27656 | | `--EXPR -> EXPR [2371:67]
27657 | | `--METHOD_CALL -> ( [2371:67]
27658 | | |--IDENT -> createModuleConfig [2371:49]
27659 | | |--ELIST -> ELIST [2371:84]
27660 | | | `--EXPR -> EXPR [2371:84]
27661 | | | `--DOT -> . [2371:84]
27662 | | | |--IDENT -> IndentationCheck [2371:68]
27663 | | | `--LITERAL_CLASS -> class [2371:85]
27664 | | `--RPAREN -> ) [2371:90]
27665 | |--SEMI -> ; [2371:91]
27666 | |--EXPR -> EXPR [2372:32]
27667 | | `--METHOD_CALL -> ( [2372:32]
27668 | | |--DOT -> . [2372:19]
27669 | | | |--IDENT -> checkConfig [2372:8]
27670 | | | `--IDENT -> addAttribute [2372:20]
27671 | | |--ELIST -> ELIST [2372:33]
27672 | | | |--EXPR -> EXPR [2372:33]
27673 | | | | `--STRING_LITERAL -> "tabWidth" [2372:33]
27674 | | | |--COMMA -> , [2372:43]
27675 | | | `--EXPR -> EXPR [2372:45]
27676 | | | `--STRING_LITERAL -> "4" [2372:45]
27677 | | `--RPAREN -> ) [2372:48]
27678 | |--SEMI -> ; [2372:49]
27679 | |--VARIABLE_DEF -> VARIABLE_DEF [2373:8]
27680 | | |--MODIFIERS -> MODIFIERS [2373:8]
27681 | | | `--FINAL -> final [2373:8]
27682 | | |--TYPE -> TYPE [2373:14]
27683 | | | `--IDENT -> String [2373:14]
27684 | | |--IDENT -> fileName [2373:21]
27685 | | `--ASSIGN -> = [2373:30]
27686 | | `--EXPR -> EXPR [2373:39]
27687 | | `--METHOD_CALL -> ( [2373:39]
27688 | | |--IDENT -> getPath [2373:32]
27689 | | |--ELIST -> ELIST [2373:40]
27690 | | | `--EXPR -> EXPR [2373:40]
27691 | | | `--STRING_LITERAL -> "InputIndentationSeparatedStatements.java" [2373:40]
27692 | | `--RPAREN -> ) [2373:82]
27693 | |--SEMI -> ; [2373:83]
27694 | |--VARIABLE_DEF -> VARIABLE_DEF [2374:8]
27695 | | |--MODIFIERS -> MODIFIERS [2374:8]
27696 | | | `--FINAL -> final [2374:8]
27697 | | |--TYPE -> TYPE [2374:20]
27698 | | | `--ARRAY_DECLARATOR -> [ [2374:20]
27699 | | | |--IDENT -> String [2374:14]
27700 | | | `--RBRACK -> ] [2374:21]
27701 | | |--IDENT -> expected [2374:23]
27702 | | `--ASSIGN -> = [2374:32]
27703 | | `--EXPR -> EXPR [2374:44]
27704 | | `--DOT -> . [2374:44]
27705 | | |--IDENT -> CommonUtil [2374:34]
27706 | | `--IDENT -> EMPTY_STRING_ARRAY [2374:45]
27707 | |--SEMI -> ; [2374:63]
27708 | |--EXPR -> EXPR [2375:19]
27709 | | `--METHOD_CALL -> ( [2375:19]
27710 | | |--IDENT -> verifyWarns [2375:8]
27711 | | |--ELIST -> ELIST [2375:20]
27712 | | | |--EXPR -> EXPR [2375:20]
27713 | | | | `--IDENT -> checkConfig [2375:20]
27714 | | | |--COMMA -> , [2375:31]
27715 | | | |--EXPR -> EXPR [2375:33]
27716 | | | | `--IDENT -> fileName [2375:33]
27717 | | | |--COMMA -> , [2375:41]
27718 | | | `--EXPR -> EXPR [2375:43]
27719 | | | `--IDENT -> expected [2375:43]
27720 | | `--RPAREN -> ) [2375:51]
27721 | |--SEMI -> ; [2375:52]
27722 | `--RCURLY -> } [2376:4]
27723 |--METHOD_DEF -> METHOD_DEF [2378:4]
27724 | |--MODIFIERS -> MODIFIERS [2378:4]
27725 | | |--ANNOTATION -> ANNOTATION [2378:4]
27726 | | | |--AT -> @ [2378:4]
27727 | | | `--IDENT -> Test [2378:5]
27728 | | `--LITERAL_PUBLIC -> public [2379:4]
27729 | |--TYPE -> TYPE [2379:11]
27730 | | `--LITERAL_VOID -> void [2379:11]
27731 | |--IDENT -> testSeparatedLineWithJustSpaces [2379:16]
27732 | |--LPAREN -> ( [2379:47]
27733 | |--PARAMETERS -> PARAMETERS [2379:48]
27734 | |--RPAREN -> ) [2379:48]
27735 | |--LITERAL_THROWS -> throws [2379:50]
27736 | | `--IDENT -> Exception [2379:57]
27737 | `--SLIST -> { [2379:67]
27738 | |--VARIABLE_DEF -> VARIABLE_DEF [2380:8]
27739 | | |--MODIFIERS -> MODIFIERS [2380:8]
27740 | | | `--FINAL -> final [2380:8]
27741 | | |--TYPE -> TYPE [2380:14]
27742 | | | `--IDENT -> DefaultConfiguration [2380:14]
27743 | | |--IDENT -> checkConfig [2380:35]
27744 | | `--ASSIGN -> = [2380:47]
27745 | | `--EXPR -> EXPR [2380:67]
27746 | | `--METHOD_CALL -> ( [2380:67]
27747 | | |--IDENT -> createModuleConfig [2380:49]
27748 | | |--ELIST -> ELIST [2380:84]
27749 | | | `--EXPR -> EXPR [2380:84]
27750 | | | `--DOT -> . [2380:84]
27751 | | | |--IDENT -> IndentationCheck [2380:68]
27752 | | | `--LITERAL_CLASS -> class [2380:85]
27753 | | `--RPAREN -> ) [2380:90]
27754 | |--SEMI -> ; [2380:91]
27755 | |--EXPR -> EXPR [2381:32]
27756 | | `--METHOD_CALL -> ( [2381:32]
27757 | | |--DOT -> . [2381:19]
27758 | | | |--IDENT -> checkConfig [2381:8]
27759 | | | `--IDENT -> addAttribute [2381:20]
27760 | | |--ELIST -> ELIST [2381:33]
27761 | | | |--EXPR -> EXPR [2381:33]
27762 | | | | `--STRING_LITERAL -> "tabWidth" [2381:33]
27763 | | | |--COMMA -> , [2381:43]
27764 | | | `--EXPR -> EXPR [2381:45]
27765 | | | `--STRING_LITERAL -> "4" [2381:45]
27766 | | `--RPAREN -> ) [2381:48]
27767 | |--SEMI -> ; [2381:49]
27768 | |--VARIABLE_DEF -> VARIABLE_DEF [2382:8]
27769 | | |--MODIFIERS -> MODIFIERS [2382:8]
27770 | | | `--FINAL -> final [2382:8]
27771 | | |--TYPE -> TYPE [2382:14]
27772 | | | `--IDENT -> String [2382:14]
27773 | | |--IDENT -> fileName [2382:21]
27774 | | `--ASSIGN -> = [2382:30]
27775 | | `--EXPR -> EXPR [2382:39]
27776 | | `--METHOD_CALL -> ( [2382:39]
27777 | | |--IDENT -> getPath [2382:32]
27778 | | |--ELIST -> ELIST [2382:40]
27779 | | | `--EXPR -> EXPR [2382:40]
27780 | | | `--STRING_LITERAL -> "InputIndentationSeparatedStatementWithSpaces.java" [2382:40]
27781 | | `--RPAREN -> ) [2382:91]
27782 | |--SEMI -> ; [2382:92]
27783 | |--VARIABLE_DEF -> VARIABLE_DEF [2383:8]
27784 | | |--MODIFIERS -> MODIFIERS [2383:8]
27785 | | | `--FINAL -> final [2383:8]
27786 | | |--TYPE -> TYPE [2383:20]
27787 | | | `--ARRAY_DECLARATOR -> [ [2383:20]
27788 | | | |--IDENT -> String [2383:14]
27789 | | | `--RBRACK -> ] [2383:21]
27790 | | |--IDENT -> expected [2383:23]
27791 | | `--ASSIGN -> = [2383:32]
27792 | | `--EXPR -> EXPR [2383:44]
27793 | | `--DOT -> . [2383:44]
27794 | | |--IDENT -> CommonUtil [2383:34]
27795 | | `--IDENT -> EMPTY_STRING_ARRAY [2383:45]
27796 | |--SEMI -> ; [2383:63]
27797 | |--EXPR -> EXPR [2384:14]
27798 | | `--METHOD_CALL -> ( [2384:14]
27799 | | |--IDENT -> verify [2384:8]
27800 | | |--ELIST -> ELIST [2384:15]
27801 | | | |--EXPR -> EXPR [2384:15]
27802 | | | | `--IDENT -> checkConfig [2384:15]
27803 | | | |--COMMA -> , [2384:26]
27804 | | | |--EXPR -> EXPR [2384:28]
27805 | | | | `--IDENT -> fileName [2384:28]
27806 | | | |--COMMA -> , [2384:36]
27807 | | | `--EXPR -> EXPR [2384:38]
27808 | | | `--IDENT -> expected [2384:38]
27809 | | `--RPAREN -> ) [2384:46]
27810 | |--SEMI -> ; [2384:47]
27811 | `--RCURLY -> } [2385:4]
27812 |--METHOD_DEF -> METHOD_DEF [2387:4]
27813 | |--MODIFIERS -> MODIFIERS [2387:4]
27814 | | |--ANNOTATION -> ANNOTATION [2387:4]
27815 | | | |--AT -> @ [2387:4]
27816 | | | `--IDENT -> Test [2387:5]
27817 | | `--LITERAL_PUBLIC -> public [2388:4]
27818 | |--TYPE -> TYPE [2388:11]
27819 | | `--LITERAL_VOID -> void [2388:11]
27820 | |--IDENT -> testTwoStatementsPerLine [2388:16]
27821 | |--LPAREN -> ( [2388:40]
27822 | |--PARAMETERS -> PARAMETERS [2388:41]
27823 | |--RPAREN -> ) [2388:41]
27824 | |--LITERAL_THROWS -> throws [2388:43]
27825 | | `--IDENT -> Exception [2388:50]
27826 | `--SLIST -> { [2388:60]
27827 | |--VARIABLE_DEF -> VARIABLE_DEF [2389:8]
27828 | | |--MODIFIERS -> MODIFIERS [2389:8]
27829 | | | `--FINAL -> final [2389:8]
27830 | | |--TYPE -> TYPE [2389:14]
27831 | | | `--IDENT -> DefaultConfiguration [2389:14]
27832 | | |--IDENT -> checkConfig [2389:35]
27833 | | `--ASSIGN -> = [2389:47]
27834 | | `--EXPR -> EXPR [2389:67]
27835 | | `--METHOD_CALL -> ( [2389:67]
27836 | | |--IDENT -> createModuleConfig [2389:49]
27837 | | |--ELIST -> ELIST [2389:84]
27838 | | | `--EXPR -> EXPR [2389:84]
27839 | | | `--DOT -> . [2389:84]
27840 | | | |--IDENT -> IndentationCheck [2389:68]
27841 | | | `--LITERAL_CLASS -> class [2389:85]
27842 | | `--RPAREN -> ) [2389:90]
27843 | |--SEMI -> ; [2389:91]
27844 | |--EXPR -> EXPR [2390:32]
27845 | | `--METHOD_CALL -> ( [2390:32]
27846 | | |--DOT -> . [2390:19]
27847 | | | |--IDENT -> checkConfig [2390:8]
27848 | | | `--IDENT -> addAttribute [2390:20]
27849 | | |--ELIST -> ELIST [2390:33]
27850 | | | |--EXPR -> EXPR [2390:33]
27851 | | | | `--STRING_LITERAL -> "tabWidth" [2390:33]
27852 | | | |--COMMA -> , [2390:43]
27853 | | | `--EXPR -> EXPR [2390:45]
27854 | | | `--STRING_LITERAL -> "4" [2390:45]
27855 | | `--RPAREN -> ) [2390:48]
27856 | |--SEMI -> ; [2390:49]
27857 | |--EXPR -> EXPR [2391:32]
27858 | | `--METHOD_CALL -> ( [2391:32]
27859 | | |--DOT -> . [2391:19]
27860 | | | |--IDENT -> checkConfig [2391:8]
27861 | | | `--IDENT -> addAttribute [2391:20]
27862 | | |--ELIST -> ELIST [2391:33]
27863 | | | |--EXPR -> EXPR [2391:33]
27864 | | | | `--STRING_LITERAL -> "basicOffset" [2391:33]
27865 | | | |--COMMA -> , [2391:46]
27866 | | | `--EXPR -> EXPR [2391:48]
27867 | | | `--STRING_LITERAL -> "4" [2391:48]
27868 | | `--RPAREN -> ) [2391:51]
27869 | |--SEMI -> ; [2391:52]
27870 | |--VARIABLE_DEF -> VARIABLE_DEF [2392:8]
27871 | | |--MODIFIERS -> MODIFIERS [2392:8]
27872 | | | `--FINAL -> final [2392:8]
27873 | | |--TYPE -> TYPE [2392:14]
27874 | | | `--IDENT -> String [2392:14]
27875 | | |--IDENT -> fileName [2392:21]
27876 | | `--ASSIGN -> = [2392:30]
27877 | | `--EXPR -> EXPR [2392:39]
27878 | | `--METHOD_CALL -> ( [2392:39]
27879 | | |--IDENT -> getPath [2392:32]
27880 | | |--ELIST -> ELIST [2392:40]
27881 | | | `--EXPR -> EXPR [2392:40]
27882 | | | `--STRING_LITERAL -> "InputIndentationTwoStatementsPerLine.java" [2392:40]
27883 | | `--RPAREN -> ) [2392:83]
27884 | |--SEMI -> ; [2392:84]
27885 | |--VARIABLE_DEF -> VARIABLE_DEF [2393:8]
27886 | | |--MODIFIERS -> MODIFIERS [2393:8]
27887 | | | `--FINAL -> final [2393:8]
27888 | | |--TYPE -> TYPE [2393:20]
27889 | | | `--ARRAY_DECLARATOR -> [ [2393:20]
27890 | | | |--IDENT -> String [2393:14]
27891 | | | `--RBRACK -> ] [2393:21]
27892 | | |--IDENT -> expected [2393:23]
27893 | | `--ASSIGN -> = [2393:32]
27894 | | `--EXPR -> EXPR [2393:44]
27895 | | `--DOT -> . [2393:44]
27896 | | |--IDENT -> CommonUtil [2393:34]
27897 | | `--IDENT -> EMPTY_STRING_ARRAY [2393:45]
27898 | |--SEMI -> ; [2393:63]
27899 | |--EXPR -> EXPR [2394:19]
27900 | | `--METHOD_CALL -> ( [2394:19]
27901 | | |--IDENT -> verifyWarns [2394:8]
27902 | | |--ELIST -> ELIST [2394:20]
27903 | | | |--EXPR -> EXPR [2394:20]
27904 | | | | `--IDENT -> checkConfig [2394:20]
27905 | | | |--COMMA -> , [2394:31]
27906 | | | |--EXPR -> EXPR [2394:33]
27907 | | | | `--IDENT -> fileName [2394:33]
27908 | | | |--COMMA -> , [2394:41]
27909 | | | `--EXPR -> EXPR [2394:43]
27910 | | | `--IDENT -> expected [2394:43]
27911 | | `--RPAREN -> ) [2394:51]
27912 | |--SEMI -> ; [2394:52]
27913 | `--RCURLY -> } [2395:4]
27914 |--METHOD_DEF -> METHOD_DEF [2397:4]
27915 | |--MODIFIERS -> MODIFIERS [2397:4]
27916 | | |--ANNOTATION -> ANNOTATION [2397:4]
27917 | | | |--AT -> @ [2397:4]
27918 | | | `--IDENT -> Test [2397:5]
27919 | | `--LITERAL_PUBLIC -> public [2398:4]
27920 | |--TYPE -> TYPE [2398:11]
27921 | | `--LITERAL_VOID -> void [2398:11]
27922 | |--IDENT -> testMethodChaining [2398:16]
27923 | |--LPAREN -> ( [2398:34]
27924 | |--PARAMETERS -> PARAMETERS [2398:35]
27925 | |--RPAREN -> ) [2398:35]
27926 | |--LITERAL_THROWS -> throws [2398:37]
27927 | | `--IDENT -> Exception [2398:44]
27928 | `--SLIST -> { [2398:54]
27929 | |--VARIABLE_DEF -> VARIABLE_DEF [2399:8]
27930 | | |--MODIFIERS -> MODIFIERS [2399:8]
27931 | | | `--FINAL -> final [2399:8]
27932 | | |--TYPE -> TYPE [2399:14]
27933 | | | `--IDENT -> DefaultConfiguration [2399:14]
27934 | | |--IDENT -> checkConfig [2399:35]
27935 | | `--ASSIGN -> = [2399:47]
27936 | | `--EXPR -> EXPR [2399:67]
27937 | | `--METHOD_CALL -> ( [2399:67]
27938 | | |--IDENT -> createModuleConfig [2399:49]
27939 | | |--ELIST -> ELIST [2399:84]
27940 | | | `--EXPR -> EXPR [2399:84]
27941 | | | `--DOT -> . [2399:84]
27942 | | | |--IDENT -> IndentationCheck [2399:68]
27943 | | | `--LITERAL_CLASS -> class [2399:85]
27944 | | `--RPAREN -> ) [2399:90]
27945 | |--SEMI -> ; [2399:91]
27946 | |--EXPR -> EXPR [2400:32]
27947 | | `--METHOD_CALL -> ( [2400:32]
27948 | | |--DOT -> . [2400:19]
27949 | | | |--IDENT -> checkConfig [2400:8]
27950 | | | `--IDENT -> addAttribute [2400:20]
27951 | | |--ELIST -> ELIST [2400:33]
27952 | | | |--EXPR -> EXPR [2400:33]
27953 | | | | `--STRING_LITERAL -> "tabWidth" [2400:33]
27954 | | | |--COMMA -> , [2400:43]
27955 | | | `--EXPR -> EXPR [2400:45]
27956 | | | `--STRING_LITERAL -> "4" [2400:45]
27957 | | `--RPAREN -> ) [2400:48]
27958 | |--SEMI -> ; [2400:49]
27959 | |--EXPR -> EXPR [2401:32]
27960 | | `--METHOD_CALL -> ( [2401:32]
27961 | | |--DOT -> . [2401:19]
27962 | | | |--IDENT -> checkConfig [2401:8]
27963 | | | `--IDENT -> addAttribute [2401:20]
27964 | | |--ELIST -> ELIST [2401:33]
27965 | | | |--EXPR -> EXPR [2401:33]
27966 | | | | `--STRING_LITERAL -> "basicOffset" [2401:33]
27967 | | | |--COMMA -> , [2401:46]
27968 | | | `--EXPR -> EXPR [2401:48]
27969 | | | `--STRING_LITERAL -> "4" [2401:48]
27970 | | `--RPAREN -> ) [2401:51]
27971 | |--SEMI -> ; [2401:52]
27972 | |--VARIABLE_DEF -> VARIABLE_DEF [2402:8]
27973 | | |--MODIFIERS -> MODIFIERS [2402:8]
27974 | | | `--FINAL -> final [2402:8]
27975 | | |--TYPE -> TYPE [2402:14]
27976 | | | `--IDENT -> String [2402:14]
27977 | | |--IDENT -> fileName [2402:21]
27978 | | `--ASSIGN -> = [2402:30]
27979 | | `--EXPR -> EXPR [2402:39]
27980 | | `--METHOD_CALL -> ( [2402:39]
27981 | | |--IDENT -> getPath [2402:32]
27982 | | |--ELIST -> ELIST [2402:40]
27983 | | | `--EXPR -> EXPR [2402:40]
27984 | | | `--STRING_LITERAL -> "InputIndentationChainedMethods.java" [2402:40]
27985 | | `--RPAREN -> ) [2402:77]
27986 | |--SEMI -> ; [2402:78]
27987 | |--VARIABLE_DEF -> VARIABLE_DEF [2403:8]
27988 | | |--MODIFIERS -> MODIFIERS [2403:8]
27989 | | | `--FINAL -> final [2403:8]
27990 | | |--TYPE -> TYPE [2403:20]
27991 | | | `--ARRAY_DECLARATOR -> [ [2403:20]
27992 | | | |--IDENT -> String [2403:14]
27993 | | | `--RBRACK -> ] [2403:21]
27994 | | |--IDENT -> expected [2403:23]
27995 | | `--ASSIGN -> = [2403:32]
27996 | | `--EXPR -> EXPR [2403:44]
27997 | | `--DOT -> . [2403:44]
27998 | | |--IDENT -> CommonUtil [2403:34]
27999 | | `--IDENT -> EMPTY_STRING_ARRAY [2403:45]
28000 | |--SEMI -> ; [2403:63]
28001 | |--EXPR -> EXPR [2404:19]
28002 | | `--METHOD_CALL -> ( [2404:19]
28003 | | |--IDENT -> verifyWarns [2404:8]
28004 | | |--ELIST -> ELIST [2404:20]
28005 | | | |--EXPR -> EXPR [2404:20]
28006 | | | | `--IDENT -> checkConfig [2404:20]
28007 | | | |--COMMA -> , [2404:31]
28008 | | | |--EXPR -> EXPR [2404:33]
28009 | | | | `--IDENT -> fileName [2404:33]
28010 | | | |--COMMA -> , [2404:41]
28011 | | | `--EXPR -> EXPR [2404:43]
28012 | | | `--IDENT -> expected [2404:43]
28013 | | `--RPAREN -> ) [2404:51]
28014 | |--SEMI -> ; [2404:52]
28015 | `--RCURLY -> } [2405:4]
28016 |--METHOD_DEF -> METHOD_DEF [2407:4]
28017 | |--MODIFIERS -> MODIFIERS [2407:4]
28018 | | |--ANNOTATION -> ANNOTATION [2407:4]
28019 | | | |--AT -> @ [2407:4]
28020 | | | `--IDENT -> Test [2407:5]
28021 | | `--LITERAL_PUBLIC -> public [2408:4]
28022 | |--TYPE -> TYPE [2408:11]
28023 | | `--LITERAL_VOID -> void [2408:11]
28024 | |--IDENT -> testMultipleAnnotationsWithWrappedLines [2408:16]
28025 | |--LPAREN -> ( [2408:55]
28026 | |--PARAMETERS -> PARAMETERS [2408:56]
28027 | |--RPAREN -> ) [2408:56]
28028 | |--LITERAL_THROWS -> throws [2408:58]
28029 | | `--IDENT -> Exception [2408:65]
28030 | `--SLIST -> { [2408:75]
28031 | |--VARIABLE_DEF -> VARIABLE_DEF [2409:8]
28032 | | |--MODIFIERS -> MODIFIERS [2409:8]
28033 | | | `--FINAL -> final [2409:8]
28034 | | |--TYPE -> TYPE [2409:14]
28035 | | | `--IDENT -> DefaultConfiguration [2409:14]
28036 | | |--IDENT -> checkConfig [2409:35]
28037 | | `--ASSIGN -> = [2409:47]
28038 | | `--EXPR -> EXPR [2409:67]
28039 | | `--METHOD_CALL -> ( [2409:67]
28040 | | |--IDENT -> createModuleConfig [2409:49]
28041 | | |--ELIST -> ELIST [2409:84]
28042 | | | `--EXPR -> EXPR [2409:84]
28043 | | | `--DOT -> . [2409:84]
28044 | | | |--IDENT -> IndentationCheck [2409:68]
28045 | | | `--LITERAL_CLASS -> class [2409:85]
28046 | | `--RPAREN -> ) [2409:90]
28047 | |--SEMI -> ; [2409:91]
28048 | |--EXPR -> EXPR [2410:32]
28049 | | `--METHOD_CALL -> ( [2410:32]
28050 | | |--DOT -> . [2410:19]
28051 | | | |--IDENT -> checkConfig [2410:8]
28052 | | | `--IDENT -> addAttribute [2410:20]
28053 | | |--ELIST -> ELIST [2410:33]
28054 | | | |--EXPR -> EXPR [2410:33]
28055 | | | | `--STRING_LITERAL -> "tabWidth" [2410:33]
28056 | | | |--COMMA -> , [2410:43]
28057 | | | `--EXPR -> EXPR [2410:45]
28058 | | | `--STRING_LITERAL -> "4" [2410:45]
28059 | | `--RPAREN -> ) [2410:48]
28060 | |--SEMI -> ; [2410:49]
28061 | |--EXPR -> EXPR [2411:32]
28062 | | `--METHOD_CALL -> ( [2411:32]
28063 | | |--DOT -> . [2411:19]
28064 | | | |--IDENT -> checkConfig [2411:8]
28065 | | | `--IDENT -> addAttribute [2411:20]
28066 | | |--ELIST -> ELIST [2411:33]
28067 | | | |--EXPR -> EXPR [2411:33]
28068 | | | | `--STRING_LITERAL -> "basicOffset" [2411:33]
28069 | | | |--COMMA -> , [2411:46]
28070 | | | `--EXPR -> EXPR [2411:48]
28071 | | | `--STRING_LITERAL -> "4" [2411:48]
28072 | | `--RPAREN -> ) [2411:51]
28073 | |--SEMI -> ; [2411:52]
28074 | |--EXPR -> EXPR [2412:32]
28075 | | `--METHOD_CALL -> ( [2412:32]
28076 | | |--DOT -> . [2412:19]
28077 | | | |--IDENT -> checkConfig [2412:8]
28078 | | | `--IDENT -> addAttribute [2412:20]
28079 | | |--ELIST -> ELIST [2412:33]
28080 | | | |--EXPR -> EXPR [2412:33]
28081 | | | | `--STRING_LITERAL -> "forceStrictCondition" [2412:33]
28082 | | | |--COMMA -> , [2412:55]
28083 | | | `--EXPR -> EXPR [2412:57]
28084 | | | `--STRING_LITERAL -> "true" [2412:57]
28085 | | `--RPAREN -> ) [2412:63]
28086 | |--SEMI -> ; [2412:64]
28087 | |--VARIABLE_DEF -> VARIABLE_DEF [2413:8]
28088 | | |--MODIFIERS -> MODIFIERS [2413:8]
28089 | | | `--FINAL -> final [2413:8]
28090 | | |--TYPE -> TYPE [2413:14]
28091 | | | `--IDENT -> String [2413:14]
28092 | | |--IDENT -> fileName [2413:21]
28093 | | `--ASSIGN -> = [2413:30]
28094 | | `--EXPR -> EXPR [2414:19]
28095 | | `--METHOD_CALL -> ( [2414:19]
28096 | | |--IDENT -> getPath [2414:12]
28097 | | |--ELIST -> ELIST [2414:20]
28098 | | | `--EXPR -> EXPR [2414:20]
28099 | | | `--STRING_LITERAL -> "InputIndentationCorrectMultipleAnnotationsWithWrappedLines.java" [2414:20]
28100 | | `--RPAREN -> ) [2414:85]
28101 | |--SEMI -> ; [2414:86]
28102 | |--VARIABLE_DEF -> VARIABLE_DEF [2415:8]
28103 | | |--MODIFIERS -> MODIFIERS [2415:8]
28104 | | | `--FINAL -> final [2415:8]
28105 | | |--TYPE -> TYPE [2415:20]
28106 | | | `--ARRAY_DECLARATOR -> [ [2415:20]
28107 | | | |--IDENT -> String [2415:14]
28108 | | | `--RBRACK -> ] [2415:21]
28109 | | |--IDENT -> expected [2415:23]
28110 | | `--ASSIGN -> = [2415:32]
28111 | | `--EXPR -> EXPR [2415:44]
28112 | | `--DOT -> . [2415:44]
28113 | | |--IDENT -> CommonUtil [2415:34]
28114 | | `--IDENT -> EMPTY_STRING_ARRAY [2415:45]
28115 | |--SEMI -> ; [2415:63]
28116 | |--EXPR -> EXPR [2416:19]
28117 | | `--METHOD_CALL -> ( [2416:19]
28118 | | |--IDENT -> verifyWarns [2416:8]
28119 | | |--ELIST -> ELIST [2416:20]
28120 | | | |--EXPR -> EXPR [2416:20]
28121 | | | | `--IDENT -> checkConfig [2416:20]
28122 | | | |--COMMA -> , [2416:31]
28123 | | | |--EXPR -> EXPR [2416:33]
28124 | | | | `--IDENT -> fileName [2416:33]
28125 | | | |--COMMA -> , [2416:41]
28126 | | | `--EXPR -> EXPR [2416:43]
28127 | | | `--IDENT -> expected [2416:43]
28128 | | `--RPAREN -> ) [2416:51]
28129 | |--SEMI -> ; [2416:52]
28130 | `--RCURLY -> } [2417:4]
28131 |--METHOD_DEF -> METHOD_DEF [2419:4]
28132 | |--MODIFIERS -> MODIFIERS [2419:4]
28133 | | |--ANNOTATION -> ANNOTATION [2419:4]
28134 | | | |--AT -> @ [2419:4]
28135 | | | `--IDENT -> Test [2419:5]
28136 | | `--LITERAL_PUBLIC -> public [2420:4]
28137 | |--TYPE -> TYPE [2420:11]
28138 | | `--LITERAL_VOID -> void [2420:11]
28139 | |--IDENT -> testMethodPrecedeByAnnotationsWithParameterOnSeparateLine [2420:16]
28140 | |--LPAREN -> ( [2420:73]
28141 | |--PARAMETERS -> PARAMETERS [2420:74]
28142 | |--RPAREN -> ) [2420:74]
28143 | |--LITERAL_THROWS -> throws [2420:76]
28144 | | `--IDENT -> Exception [2420:83]
28145 | `--SLIST -> { [2420:93]
28146 | |--VARIABLE_DEF -> VARIABLE_DEF [2421:8]
28147 | | |--MODIFIERS -> MODIFIERS [2421:8]
28148 | | | `--FINAL -> final [2421:8]
28149 | | |--TYPE -> TYPE [2421:14]
28150 | | | `--IDENT -> DefaultConfiguration [2421:14]
28151 | | |--IDENT -> checkConfig [2421:35]
28152 | | `--ASSIGN -> = [2421:47]
28153 | | `--EXPR -> EXPR [2421:67]
28154 | | `--METHOD_CALL -> ( [2421:67]
28155 | | |--IDENT -> createModuleConfig [2421:49]
28156 | | |--ELIST -> ELIST [2421:84]
28157 | | | `--EXPR -> EXPR [2421:84]
28158 | | | `--DOT -> . [2421:84]
28159 | | | |--IDENT -> IndentationCheck [2421:68]
28160 | | | `--LITERAL_CLASS -> class [2421:85]
28161 | | `--RPAREN -> ) [2421:90]
28162 | |--SEMI -> ; [2421:91]
28163 | |--EXPR -> EXPR [2422:32]
28164 | | `--METHOD_CALL -> ( [2422:32]
28165 | | |--DOT -> . [2422:19]
28166 | | | |--IDENT -> checkConfig [2422:8]
28167 | | | `--IDENT -> addAttribute [2422:20]
28168 | | |--ELIST -> ELIST [2422:33]
28169 | | | |--EXPR -> EXPR [2422:33]
28170 | | | | `--STRING_LITERAL -> "tabWidth" [2422:33]
28171 | | | |--COMMA -> , [2422:43]
28172 | | | `--EXPR -> EXPR [2422:45]
28173 | | | `--STRING_LITERAL -> "4" [2422:45]
28174 | | `--RPAREN -> ) [2422:48]
28175 | |--SEMI -> ; [2422:49]
28176 | |--EXPR -> EXPR [2423:32]
28177 | | `--METHOD_CALL -> ( [2423:32]
28178 | | |--DOT -> . [2423:19]
28179 | | | |--IDENT -> checkConfig [2423:8]
28180 | | | `--IDENT -> addAttribute [2423:20]
28181 | | |--ELIST -> ELIST [2423:33]
28182 | | | |--EXPR -> EXPR [2423:33]
28183 | | | | `--STRING_LITERAL -> "basicOffset" [2423:33]
28184 | | | |--COMMA -> , [2423:46]
28185 | | | `--EXPR -> EXPR [2423:48]
28186 | | | `--STRING_LITERAL -> "2" [2423:48]
28187 | | `--RPAREN -> ) [2423:51]
28188 | |--SEMI -> ; [2423:52]
28189 | |--EXPR -> EXPR [2424:32]
28190 | | `--METHOD_CALL -> ( [2424:32]
28191 | | |--DOT -> . [2424:19]
28192 | | | |--IDENT -> checkConfig [2424:8]
28193 | | | `--IDENT -> addAttribute [2424:20]
28194 | | |--ELIST -> ELIST [2424:33]
28195 | | | |--EXPR -> EXPR [2424:33]
28196 | | | | `--STRING_LITERAL -> "braceAdjustment" [2424:33]
28197 | | | |--COMMA -> , [2424:50]
28198 | | | `--EXPR -> EXPR [2424:52]
28199 | | | `--STRING_LITERAL -> "0" [2424:52]
28200 | | `--RPAREN -> ) [2424:55]
28201 | |--SEMI -> ; [2424:56]
28202 | |--EXPR -> EXPR [2425:32]
28203 | | `--METHOD_CALL -> ( [2425:32]
28204 | | |--DOT -> . [2425:19]
28205 | | | |--IDENT -> checkConfig [2425:8]
28206 | | | `--IDENT -> addAttribute [2425:20]
28207 | | |--ELIST -> ELIST [2425:33]
28208 | | | |--EXPR -> EXPR [2425:33]
28209 | | | | `--STRING_LITERAL -> "caseIndent" [2425:33]
28210 | | | |--COMMA -> , [2425:45]
28211 | | | `--EXPR -> EXPR [2425:47]
28212 | | | `--STRING_LITERAL -> "2" [2425:47]
28213 | | `--RPAREN -> ) [2425:50]
28214 | |--SEMI -> ; [2425:51]
28215 | |--EXPR -> EXPR [2426:32]
28216 | | `--METHOD_CALL -> ( [2426:32]
28217 | | |--DOT -> . [2426:19]
28218 | | | |--IDENT -> checkConfig [2426:8]
28219 | | | `--IDENT -> addAttribute [2426:20]
28220 | | |--ELIST -> ELIST [2426:33]
28221 | | | |--EXPR -> EXPR [2426:33]
28222 | | | | `--STRING_LITERAL -> "throwsIndent" [2426:33]
28223 | | | |--COMMA -> , [2426:47]
28224 | | | `--EXPR -> EXPR [2426:49]
28225 | | | `--STRING_LITERAL -> "4" [2426:49]
28226 | | `--RPAREN -> ) [2426:52]
28227 | |--SEMI -> ; [2426:53]
28228 | |--EXPR -> EXPR [2427:32]
28229 | | `--METHOD_CALL -> ( [2427:32]
28230 | | |--DOT -> . [2427:19]
28231 | | | |--IDENT -> checkConfig [2427:8]
28232 | | | `--IDENT -> addAttribute [2427:20]
28233 | | |--ELIST -> ELIST [2427:33]
28234 | | | |--EXPR -> EXPR [2427:33]
28235 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2427:33]
28236 | | | |--COMMA -> , [2427:58]
28237 | | | `--EXPR -> EXPR [2427:60]
28238 | | | `--STRING_LITERAL -> "4" [2427:60]
28239 | | `--RPAREN -> ) [2427:63]
28240 | |--SEMI -> ; [2427:64]
28241 | |--EXPR -> EXPR [2428:32]
28242 | | `--METHOD_CALL -> ( [2428:32]
28243 | | |--DOT -> . [2428:19]
28244 | | | |--IDENT -> checkConfig [2428:8]
28245 | | | `--IDENT -> addAttribute [2428:20]
28246 | | |--ELIST -> ELIST [2428:33]
28247 | | | |--EXPR -> EXPR [2428:33]
28248 | | | | `--STRING_LITERAL -> "arrayInitIndent" [2428:33]
28249 | | | |--COMMA -> , [2428:50]
28250 | | | `--EXPR -> EXPR [2428:52]
28251 | | | `--STRING_LITERAL -> "2" [2428:52]
28252 | | `--RPAREN -> ) [2428:55]
28253 | |--SEMI -> ; [2428:56]
28254 | |--VARIABLE_DEF -> VARIABLE_DEF [2429:8]
28255 | | |--MODIFIERS -> MODIFIERS [2429:8]
28256 | | | `--FINAL -> final [2429:8]
28257 | | |--TYPE -> TYPE [2429:14]
28258 | | | `--IDENT -> String [2429:14]
28259 | | |--IDENT -> fileName [2429:21]
28260 | | `--ASSIGN -> = [2429:30]
28261 | | `--EXPR -> EXPR [2430:19]
28262 | | `--METHOD_CALL -> ( [2430:19]
28263 | | |--IDENT -> getPath [2430:12]
28264 | | |--ELIST -> ELIST [2430:20]
28265 | | | `--EXPR -> EXPR [2430:20]
28266 | | | `--STRING_LITERAL -> "InputIndentationMethodPrecededByAnnotationWithParameterOnSeparateLine.java" [2430:20]
28267 | | `--RPAREN -> ) [2430:96]
28268 | |--SEMI -> ; [2430:97]
28269 | |--VARIABLE_DEF -> VARIABLE_DEF [2431:8]
28270 | | |--MODIFIERS -> MODIFIERS [2431:8]
28271 | | | `--FINAL -> final [2431:8]
28272 | | |--TYPE -> TYPE [2431:20]
28273 | | | `--ARRAY_DECLARATOR -> [ [2431:20]
28274 | | | |--IDENT -> String [2431:14]
28275 | | | `--RBRACK -> ] [2431:21]
28276 | | |--IDENT -> expected [2431:23]
28277 | | `--ASSIGN -> = [2431:32]
28278 | | `--EXPR -> EXPR [2431:44]
28279 | | `--DOT -> . [2431:44]
28280 | | |--IDENT -> CommonUtil [2431:34]
28281 | | `--IDENT -> EMPTY_STRING_ARRAY [2431:45]
28282 | |--SEMI -> ; [2431:63]
28283 | |--EXPR -> EXPR [2432:14]
28284 | | `--METHOD_CALL -> ( [2432:14]
28285 | | |--IDENT -> verify [2432:8]
28286 | | |--ELIST -> ELIST [2432:15]
28287 | | | |--EXPR -> EXPR [2432:15]
28288 | | | | `--IDENT -> checkConfig [2432:15]
28289 | | | |--COMMA -> , [2432:26]
28290 | | | |--EXPR -> EXPR [2432:28]
28291 | | | | `--IDENT -> fileName [2432:28]
28292 | | | |--COMMA -> , [2432:36]
28293 | | | `--EXPR -> EXPR [2432:38]
28294 | | | `--IDENT -> expected [2432:38]
28295 | | `--RPAREN -> ) [2432:46]
28296 | |--SEMI -> ; [2432:47]
28297 | `--RCURLY -> } [2433:4]
28298 |--METHOD_DEF -> METHOD_DEF [2435:4]
28299 | |--MODIFIERS -> MODIFIERS [2435:4]
28300 | | |--ANNOTATION -> ANNOTATION [2435:4]
28301 | | | |--AT -> @ [2435:4]
28302 | | | `--IDENT -> Test [2435:5]
28303 | | `--LITERAL_PUBLIC -> public [2436:4]
28304 | |--TYPE -> TYPE [2436:11]
28305 | | `--LITERAL_VOID -> void [2436:11]
28306 | |--IDENT -> testAnnotationIncorrect [2436:16]
28307 | |--LPAREN -> ( [2436:39]
28308 | |--PARAMETERS -> PARAMETERS [2436:40]
28309 | |--RPAREN -> ) [2436:40]
28310 | |--LITERAL_THROWS -> throws [2436:42]
28311 | | `--IDENT -> Exception [2436:49]
28312 | `--SLIST -> { [2436:59]
28313 | |--VARIABLE_DEF -> VARIABLE_DEF [2437:8]
28314 | | |--MODIFIERS -> MODIFIERS [2437:8]
28315 | | | `--FINAL -> final [2437:8]
28316 | | |--TYPE -> TYPE [2437:14]
28317 | | | `--IDENT -> DefaultConfiguration [2437:14]
28318 | | |--IDENT -> checkConfig [2437:35]
28319 | | `--ASSIGN -> = [2437:47]
28320 | | `--EXPR -> EXPR [2437:67]
28321 | | `--METHOD_CALL -> ( [2437:67]
28322 | | |--IDENT -> createModuleConfig [2437:49]
28323 | | |--ELIST -> ELIST [2437:84]
28324 | | | `--EXPR -> EXPR [2437:84]
28325 | | | `--DOT -> . [2437:84]
28326 | | | |--IDENT -> IndentationCheck [2437:68]
28327 | | | `--LITERAL_CLASS -> class [2437:85]
28328 | | `--RPAREN -> ) [2437:90]
28329 | |--SEMI -> ; [2437:91]
28330 | |--EXPR -> EXPR [2438:32]
28331 | | `--METHOD_CALL -> ( [2438:32]
28332 | | |--DOT -> . [2438:19]
28333 | | | |--IDENT -> checkConfig [2438:8]
28334 | | | `--IDENT -> addAttribute [2438:20]
28335 | | |--ELIST -> ELIST [2438:33]
28336 | | | |--EXPR -> EXPR [2438:33]
28337 | | | | `--STRING_LITERAL -> "tabWidth" [2438:33]
28338 | | | |--COMMA -> , [2438:43]
28339 | | | `--EXPR -> EXPR [2438:45]
28340 | | | `--STRING_LITERAL -> "4" [2438:45]
28341 | | `--RPAREN -> ) [2438:48]
28342 | |--SEMI -> ; [2438:49]
28343 | |--EXPR -> EXPR [2439:32]
28344 | | `--METHOD_CALL -> ( [2439:32]
28345 | | |--DOT -> . [2439:19]
28346 | | | |--IDENT -> checkConfig [2439:8]
28347 | | | `--IDENT -> addAttribute [2439:20]
28348 | | |--ELIST -> ELIST [2439:33]
28349 | | | |--EXPR -> EXPR [2439:33]
28350 | | | | `--STRING_LITERAL -> "basicOffset" [2439:33]
28351 | | | |--COMMA -> , [2439:46]
28352 | | | `--EXPR -> EXPR [2439:48]
28353 | | | `--STRING_LITERAL -> "4" [2439:48]
28354 | | `--RPAREN -> ) [2439:51]
28355 | |--SEMI -> ; [2439:52]
28356 | |--EXPR -> EXPR [2440:32]
28357 | | `--METHOD_CALL -> ( [2440:32]
28358 | | |--DOT -> . [2440:19]
28359 | | | |--IDENT -> checkConfig [2440:8]
28360 | | | `--IDENT -> addAttribute [2440:20]
28361 | | |--ELIST -> ELIST [2440:33]
28362 | | | |--EXPR -> EXPR [2440:33]
28363 | | | | `--STRING_LITERAL -> "braceAdjustment" [2440:33]
28364 | | | |--COMMA -> , [2440:50]
28365 | | | `--EXPR -> EXPR [2440:52]
28366 | | | `--STRING_LITERAL -> "0" [2440:52]
28367 | | `--RPAREN -> ) [2440:55]
28368 | |--SEMI -> ; [2440:56]
28369 | |--EXPR -> EXPR [2441:32]
28370 | | `--METHOD_CALL -> ( [2441:32]
28371 | | |--DOT -> . [2441:19]
28372 | | | |--IDENT -> checkConfig [2441:8]
28373 | | | `--IDENT -> addAttribute [2441:20]
28374 | | |--ELIST -> ELIST [2441:33]
28375 | | | |--EXPR -> EXPR [2441:33]
28376 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2441:33]
28377 | | | |--COMMA -> , [2441:58]
28378 | | | `--EXPR -> EXPR [2441:60]
28379 | | | `--STRING_LITERAL -> "4" [2441:60]
28380 | | `--RPAREN -> ) [2441:63]
28381 | |--SEMI -> ; [2441:64]
28382 | |--VARIABLE_DEF -> VARIABLE_DEF [2442:8]
28383 | | |--MODIFIERS -> MODIFIERS [2442:8]
28384 | | | `--FINAL -> final [2442:8]
28385 | | |--TYPE -> TYPE [2442:14]
28386 | | | `--IDENT -> String [2442:14]
28387 | | |--IDENT -> fileName [2442:21]
28388 | | `--ASSIGN -> = [2442:30]
28389 | | `--EXPR -> EXPR [2443:19]
28390 | | `--METHOD_CALL -> ( [2443:19]
28391 | | |--IDENT -> getPath [2443:12]
28392 | | |--ELIST -> ELIST [2443:20]
28393 | | | `--EXPR -> EXPR [2443:20]
28394 | | | `--STRING_LITERAL -> "InputIndentationAnnotationIncorrect.java" [2443:20]
28395 | | `--RPAREN -> ) [2443:62]
28396 | |--SEMI -> ; [2443:63]
28397 | |--VARIABLE_DEF -> VARIABLE_DEF [2444:8]
28398 | | |--MODIFIERS -> MODIFIERS [2444:8]
28399 | | | `--FINAL -> final [2444:8]
28400 | | |--TYPE -> TYPE [2444:20]
28401 | | | `--ARRAY_DECLARATOR -> [ [2444:20]
28402 | | | |--IDENT -> String [2444:14]
28403 | | | `--RBRACK -> ] [2444:21]
28404 | | |--IDENT -> expected [2444:23]
28405 | | `--ASSIGN -> = [2444:32]
28406 | | `--ARRAY_INIT -> { [2444:34]
28407 | | |--EXPR -> EXPR [2445:21]
28408 | | | `--PLUS -> + [2445:21]
28409 | | | |--STRING_LITERAL -> "11:5: " [2445:12]
28410 | | | `--METHOD_CALL -> ( [2445:38]
28411 | | | |--IDENT -> getCheckMessage [2445:23]
28412 | | | |--ELIST -> ELIST [2445:39]
28413 | | | | |--EXPR -> EXPR [2445:39]
28414 | | | | | `--IDENT -> MSG_ERROR [2445:39]
28415 | | | | |--COMMA -> , [2445:48]
28416 | | | | |--EXPR -> EXPR [2445:50]
28417 | | | | | `--STRING_LITERAL -> "(" [2445:50]
28418 | | | | |--COMMA -> , [2445:53]
28419 | | | | |--EXPR -> EXPR [2445:55]
28420 | | | | | `--NUM_INT -> 4 [2445:55]
28421 | | | | |--COMMA -> , [2445:56]
28422 | | | | `--EXPR -> EXPR [2445:58]
28423 | | | | `--NUM_INT -> 8 [2445:58]
28424 | | | `--RPAREN -> ) [2445:59]
28425 | | |--COMMA -> , [2445:60]
28426 | | |--EXPR -> EXPR [2446:21]
28427 | | | `--PLUS -> + [2446:21]
28428 | | | |--STRING_LITERAL -> "14:9: " [2446:12]
28429 | | | `--METHOD_CALL -> ( [2446:38]
28430 | | | |--IDENT -> getCheckMessage [2446:23]
28431 | | | |--ELIST -> ELIST [2446:39]
28432 | | | | |--EXPR -> EXPR [2446:39]
28433 | | | | | `--IDENT -> MSG_ERROR [2446:39]
28434 | | | | |--COMMA -> , [2446:48]
28435 | | | | |--EXPR -> EXPR [2446:50]
28436 | | | | | `--STRING_LITERAL -> "(" [2446:50]
28437 | | | | |--COMMA -> , [2446:53]
28438 | | | | |--EXPR -> EXPR [2446:55]
28439 | | | | | `--NUM_INT -> 8 [2446:55]
28440 | | | | |--COMMA -> , [2446:56]
28441 | | | | `--EXPR -> EXPR [2446:58]
28442 | | | | `--NUM_INT -> 12 [2446:58]
28443 | | | `--RPAREN -> ) [2446:60]
28444 | | |--COMMA -> , [2446:61]
28445 | | |--EXPR -> EXPR [2447:21]
28446 | | | `--PLUS -> + [2447:21]
28447 | | | |--STRING_LITERAL -> "19:5: " [2447:12]
28448 | | | `--METHOD_CALL -> ( [2447:38]
28449 | | | |--IDENT -> getCheckMessage [2447:23]
28450 | | | |--ELIST -> ELIST [2447:39]
28451 | | | | |--EXPR -> EXPR [2447:39]
28452 | | | | | `--IDENT -> MSG_ERROR [2447:39]
28453 | | | | |--COMMA -> , [2447:48]
28454 | | | | |--EXPR -> EXPR [2447:50]
28455 | | | | | `--STRING_LITERAL -> "(" [2447:50]
28456 | | | | |--COMMA -> , [2447:53]
28457 | | | | |--EXPR -> EXPR [2447:55]
28458 | | | | | `--NUM_INT -> 4 [2447:55]
28459 | | | | |--COMMA -> , [2447:56]
28460 | | | | `--EXPR -> EXPR [2447:58]
28461 | | | | `--NUM_INT -> 8 [2447:58]
28462 | | | `--RPAREN -> ) [2447:59]
28463 | | |--COMMA -> , [2447:60]
28464 | | `--RCURLY -> } [2448:8]
28465 | |--SEMI -> ; [2448:9]
28466 | |--EXPR -> EXPR [2449:14]
28467 | | `--METHOD_CALL -> ( [2449:14]
28468 | | |--IDENT -> verify [2449:8]
28469 | | |--ELIST -> ELIST [2449:15]
28470 | | | |--EXPR -> EXPR [2449:15]
28471 | | | | `--IDENT -> checkConfig [2449:15]
28472 | | | |--COMMA -> , [2449:26]
28473 | | | |--EXPR -> EXPR [2449:28]
28474 | | | | `--IDENT -> fileName [2449:28]
28475 | | | |--COMMA -> , [2449:36]
28476 | | | `--EXPR -> EXPR [2449:38]
28477 | | | `--IDENT -> expected [2449:38]
28478 | | `--RPAREN -> ) [2449:46]
28479 | |--SEMI -> ; [2449:47]
28480 | `--RCURLY -> } [2450:4]
28481 |--METHOD_DEF -> METHOD_DEF [2452:4]
28482 | |--MODIFIERS -> MODIFIERS [2452:4]
28483 | | |--ANNOTATION -> ANNOTATION [2452:4]
28484 | | | |--AT -> @ [2452:4]
28485 | | | `--IDENT -> Test [2452:5]
28486 | | `--LITERAL_PUBLIC -> public [2453:4]
28487 | |--TYPE -> TYPE [2453:11]
28488 | | `--LITERAL_VOID -> void [2453:11]
28489 | |--IDENT -> testInputAnnotationScopeIndentationCheck [2453:16]
28490 | |--LPAREN -> ( [2453:56]
28491 | |--PARAMETERS -> PARAMETERS [2453:57]
28492 | |--RPAREN -> ) [2453:57]
28493 | |--LITERAL_THROWS -> throws [2453:59]
28494 | | `--IDENT -> Exception [2453:66]
28495 | `--SLIST -> { [2453:76]
28496 | |--VARIABLE_DEF -> VARIABLE_DEF [2454:8]
28497 | | |--MODIFIERS -> MODIFIERS [2454:8]
28498 | | | `--FINAL -> final [2454:8]
28499 | | |--TYPE -> TYPE [2454:14]
28500 | | | `--IDENT -> DefaultConfiguration [2454:14]
28501 | | |--IDENT -> checkConfig [2454:35]
28502 | | `--ASSIGN -> = [2454:47]
28503 | | `--EXPR -> EXPR [2454:67]
28504 | | `--METHOD_CALL -> ( [2454:67]
28505 | | |--IDENT -> createModuleConfig [2454:49]
28506 | | |--ELIST -> ELIST [2454:84]
28507 | | | `--EXPR -> EXPR [2454:84]
28508 | | | `--DOT -> . [2454:84]
28509 | | | |--IDENT -> IndentationCheck [2454:68]
28510 | | | `--LITERAL_CLASS -> class [2454:85]
28511 | | `--RPAREN -> ) [2454:90]
28512 | |--SEMI -> ; [2454:91]
28513 | |--EXPR -> EXPR [2455:32]
28514 | | `--METHOD_CALL -> ( [2455:32]
28515 | | |--DOT -> . [2455:19]
28516 | | | |--IDENT -> checkConfig [2455:8]
28517 | | | `--IDENT -> addAttribute [2455:20]
28518 | | |--ELIST -> ELIST [2455:33]
28519 | | | |--EXPR -> EXPR [2455:33]
28520 | | | | `--STRING_LITERAL -> "tabWidth" [2455:33]
28521 | | | |--COMMA -> , [2455:43]
28522 | | | `--EXPR -> EXPR [2455:45]
28523 | | | `--STRING_LITERAL -> "4" [2455:45]
28524 | | `--RPAREN -> ) [2455:48]
28525 | |--SEMI -> ; [2455:49]
28526 | |--EXPR -> EXPR [2456:32]
28527 | | `--METHOD_CALL -> ( [2456:32]
28528 | | |--DOT -> . [2456:19]
28529 | | | |--IDENT -> checkConfig [2456:8]
28530 | | | `--IDENT -> addAttribute [2456:20]
28531 | | |--ELIST -> ELIST [2456:33]
28532 | | | |--EXPR -> EXPR [2456:33]
28533 | | | | `--STRING_LITERAL -> "basicOffset" [2456:33]
28534 | | | |--COMMA -> , [2456:46]
28535 | | | `--EXPR -> EXPR [2456:48]
28536 | | | `--STRING_LITERAL -> "4" [2456:48]
28537 | | `--RPAREN -> ) [2456:51]
28538 | |--SEMI -> ; [2456:52]
28539 | |--EXPR -> EXPR [2457:32]
28540 | | `--METHOD_CALL -> ( [2457:32]
28541 | | |--DOT -> . [2457:19]
28542 | | | |--IDENT -> checkConfig [2457:8]
28543 | | | `--IDENT -> addAttribute [2457:20]
28544 | | |--ELIST -> ELIST [2457:33]
28545 | | | |--EXPR -> EXPR [2457:33]
28546 | | | | `--STRING_LITERAL -> "forceStrictCondition" [2457:33]
28547 | | | |--COMMA -> , [2457:55]
28548 | | | `--EXPR -> EXPR [2457:57]
28549 | | | `--STRING_LITERAL -> "true" [2457:57]
28550 | | `--RPAREN -> ) [2457:63]
28551 | |--SEMI -> ; [2457:64]
28552 | |--VARIABLE_DEF -> VARIABLE_DEF [2458:8]
28553 | | |--MODIFIERS -> MODIFIERS [2458:8]
28554 | | | `--FINAL -> final [2458:8]
28555 | | |--TYPE -> TYPE [2458:14]
28556 | | | `--IDENT -> String [2458:14]
28557 | | |--IDENT -> fileName [2458:21]
28558 | | `--ASSIGN -> = [2458:30]
28559 | | `--EXPR -> EXPR [2458:39]
28560 | | `--METHOD_CALL -> ( [2458:39]
28561 | | |--IDENT -> getPath [2458:32]
28562 | | |--ELIST -> ELIST [2458:40]
28563 | | | `--EXPR -> EXPR [2458:40]
28564 | | | `--STRING_LITERAL -> "InputIndentationAnnotationScopeIndentationCheck.java" [2458:40]
28565 | | `--RPAREN -> ) [2458:94]
28566 | |--SEMI -> ; [2458:95]
28567 | |--VARIABLE_DEF -> VARIABLE_DEF [2459:8]
28568 | | |--MODIFIERS -> MODIFIERS [2459:8]
28569 | | | `--FINAL -> final [2459:8]
28570 | | |--TYPE -> TYPE [2459:20]
28571 | | | `--ARRAY_DECLARATOR -> [ [2459:20]
28572 | | | |--IDENT -> String [2459:14]
28573 | | | `--RBRACK -> ] [2459:21]
28574 | | |--IDENT -> expected [2459:23]
28575 | | `--ASSIGN -> = [2459:32]
28576 | | `--ARRAY_INIT -> { [2459:34]
28577 | | |--EXPR -> EXPR [2460:20]
28578 | | | `--PLUS -> + [2460:20]
28579 | | | |--STRING_LITERAL -> "9:9: " [2460:12]
28580 | | | `--METHOD_CALL -> ( [2460:37]
28581 | | | |--IDENT -> getCheckMessage [2460:22]
28582 | | | |--ELIST -> ELIST [2460:38]
28583 | | | | |--EXPR -> EXPR [2460:38]
28584 | | | | | `--IDENT -> MSG_ERROR_MULTI [2460:38]
28585 | | | | |--COMMA -> , [2460:53]
28586 | | | | |--EXPR -> EXPR [2461:20]
28587 | | | | | `--STRING_LITERAL -> "annotation array initialization rcurly" [2461:20]
28588 | | | | |--COMMA -> , [2461:60]
28589 | | | | |--EXPR -> EXPR [2461:62]
28590 | | | | | `--NUM_INT -> 8 [2461:62]
28591 | | | | |--COMMA -> , [2461:63]
28592 | | | | `--EXPR -> EXPR [2461:65]
28593 | | | | `--STRING_LITERAL -> "0, 4" [2461:65]
28594 | | | `--RPAREN -> ) [2461:71]
28595 | | |--COMMA -> , [2461:72]
28596 | | `--RCURLY -> } [2462:8]
28597 | |--SEMI -> ; [2462:9]
28598 | |--EXPR -> EXPR [2463:19]
28599 | | `--METHOD_CALL -> ( [2463:19]
28600 | | |--IDENT -> verifyWarns [2463:8]
28601 | | |--ELIST -> ELIST [2463:20]
28602 | | | |--EXPR -> EXPR [2463:20]
28603 | | | | `--IDENT -> checkConfig [2463:20]
28604 | | | |--COMMA -> , [2463:31]
28605 | | | |--EXPR -> EXPR [2463:33]
28606 | | | | `--IDENT -> fileName [2463:33]
28607 | | | |--COMMA -> , [2463:41]
28608 | | | `--EXPR -> EXPR [2463:43]
28609 | | | `--IDENT -> expected [2463:43]
28610 | | `--RPAREN -> ) [2463:51]
28611 | |--SEMI -> ; [2463:52]
28612 | `--RCURLY -> } [2464:4]
28613 |--METHOD_DEF -> METHOD_DEF [2466:4]
28614 | |--MODIFIERS -> MODIFIERS [2466:4]
28615 | | |--ANNOTATION -> ANNOTATION [2466:4]
28616 | | | |--AT -> @ [2466:4]
28617 | | | `--IDENT -> Test [2466:5]
28618 | | `--LITERAL_PUBLIC -> public [2467:4]
28619 | |--TYPE -> TYPE [2467:11]
28620 | | `--LITERAL_VOID -> void [2467:11]
28621 | |--IDENT -> testInputAnnotationDefIndentationCheck [2467:16]
28622 | |--LPAREN -> ( [2467:54]
28623 | |--PARAMETERS -> PARAMETERS [2467:55]
28624 | |--RPAREN -> ) [2467:55]
28625 | |--LITERAL_THROWS -> throws [2467:57]
28626 | | `--IDENT -> Exception [2467:64]
28627 | `--SLIST -> { [2467:74]
28628 | |--VARIABLE_DEF -> VARIABLE_DEF [2468:8]
28629 | | |--MODIFIERS -> MODIFIERS [2468:8]
28630 | | | `--FINAL -> final [2468:8]
28631 | | |--TYPE -> TYPE [2468:14]
28632 | | | `--IDENT -> DefaultConfiguration [2468:14]
28633 | | |--IDENT -> checkConfig [2468:35]
28634 | | `--ASSIGN -> = [2468:47]
28635 | | `--EXPR -> EXPR [2468:67]
28636 | | `--METHOD_CALL -> ( [2468:67]
28637 | | |--IDENT -> createModuleConfig [2468:49]
28638 | | |--ELIST -> ELIST [2468:84]
28639 | | | `--EXPR -> EXPR [2468:84]
28640 | | | `--DOT -> . [2468:84]
28641 | | | |--IDENT -> IndentationCheck [2468:68]
28642 | | | `--LITERAL_CLASS -> class [2468:85]
28643 | | `--RPAREN -> ) [2468:90]
28644 | |--SEMI -> ; [2468:91]
28645 | |--EXPR -> EXPR [2469:32]
28646 | | `--METHOD_CALL -> ( [2469:32]
28647 | | |--DOT -> . [2469:19]
28648 | | | |--IDENT -> checkConfig [2469:8]
28649 | | | `--IDENT -> addAttribute [2469:20]
28650 | | |--ELIST -> ELIST [2469:33]
28651 | | | |--EXPR -> EXPR [2469:33]
28652 | | | | `--STRING_LITERAL -> "tabWidth" [2469:33]
28653 | | | |--COMMA -> , [2469:43]
28654 | | | `--EXPR -> EXPR [2469:45]
28655 | | | `--STRING_LITERAL -> "4" [2469:45]
28656 | | `--RPAREN -> ) [2469:48]
28657 | |--SEMI -> ; [2469:49]
28658 | |--EXPR -> EXPR [2470:32]
28659 | | `--METHOD_CALL -> ( [2470:32]
28660 | | |--DOT -> . [2470:19]
28661 | | | |--IDENT -> checkConfig [2470:8]
28662 | | | `--IDENT -> addAttribute [2470:20]
28663 | | |--ELIST -> ELIST [2470:33]
28664 | | | |--EXPR -> EXPR [2470:33]
28665 | | | | `--STRING_LITERAL -> "arrayInitIndent" [2470:33]
28666 | | | |--COMMA -> , [2470:50]
28667 | | | `--EXPR -> EXPR [2470:52]
28668 | | | `--STRING_LITERAL -> "4" [2470:52]
28669 | | `--RPAREN -> ) [2470:55]
28670 | |--SEMI -> ; [2470:56]
28671 | |--EXPR -> EXPR [2471:32]
28672 | | `--METHOD_CALL -> ( [2471:32]
28673 | | |--DOT -> . [2471:19]
28674 | | | |--IDENT -> checkConfig [2471:8]
28675 | | | `--IDENT -> addAttribute [2471:20]
28676 | | |--ELIST -> ELIST [2471:33]
28677 | | | |--EXPR -> EXPR [2471:33]
28678 | | | | `--STRING_LITERAL -> "basicOffset" [2471:33]
28679 | | | |--COMMA -> , [2471:46]
28680 | | | `--EXPR -> EXPR [2471:48]
28681 | | | `--STRING_LITERAL -> "4" [2471:48]
28682 | | `--RPAREN -> ) [2471:51]
28683 | |--SEMI -> ; [2471:52]
28684 | |--EXPR -> EXPR [2472:32]
28685 | | `--METHOD_CALL -> ( [2472:32]
28686 | | |--DOT -> . [2472:19]
28687 | | | |--IDENT -> checkConfig [2472:8]
28688 | | | `--IDENT -> addAttribute [2472:20]
28689 | | |--ELIST -> ELIST [2472:33]
28690 | | | |--EXPR -> EXPR [2472:33]
28691 | | | | `--STRING_LITERAL -> "braceAdjustment" [2472:33]
28692 | | | |--COMMA -> , [2472:50]
28693 | | | `--EXPR -> EXPR [2472:52]
28694 | | | `--STRING_LITERAL -> "0" [2472:52]
28695 | | `--RPAREN -> ) [2472:55]
28696 | |--SEMI -> ; [2472:56]
28697 | |--EXPR -> EXPR [2473:32]
28698 | | `--METHOD_CALL -> ( [2473:32]
28699 | | |--DOT -> . [2473:19]
28700 | | | |--IDENT -> checkConfig [2473:8]
28701 | | | `--IDENT -> addAttribute [2473:20]
28702 | | |--ELIST -> ELIST [2473:33]
28703 | | | |--EXPR -> EXPR [2473:33]
28704 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2473:33]
28705 | | | |--COMMA -> , [2473:58]
28706 | | | `--EXPR -> EXPR [2473:60]
28707 | | | `--STRING_LITERAL -> "4" [2473:60]
28708 | | `--RPAREN -> ) [2473:63]
28709 | |--SEMI -> ; [2473:64]
28710 | |--EXPR -> EXPR [2474:32]
28711 | | `--METHOD_CALL -> ( [2474:32]
28712 | | |--DOT -> . [2474:19]
28713 | | | |--IDENT -> checkConfig [2474:8]
28714 | | | `--IDENT -> addAttribute [2474:20]
28715 | | |--ELIST -> ELIST [2474:33]
28716 | | | |--EXPR -> EXPR [2474:33]
28717 | | | | `--STRING_LITERAL -> "forceStrictCondition" [2474:33]
28718 | | | |--COMMA -> , [2474:55]
28719 | | | `--EXPR -> EXPR [2474:57]
28720 | | | `--STRING_LITERAL -> "true" [2474:57]
28721 | | `--RPAREN -> ) [2474:63]
28722 | |--SEMI -> ; [2474:64]
28723 | |--VARIABLE_DEF -> VARIABLE_DEF [2475:8]
28724 | | |--MODIFIERS -> MODIFIERS [2475:8]
28725 | | | `--FINAL -> final [2475:8]
28726 | | |--TYPE -> TYPE [2475:14]
28727 | | | `--IDENT -> String [2475:14]
28728 | | |--IDENT -> fileName [2475:21]
28729 | | `--ASSIGN -> = [2475:30]
28730 | | `--EXPR -> EXPR [2475:39]
28731 | | `--METHOD_CALL -> ( [2475:39]
28732 | | |--IDENT -> getPath [2475:32]
28733 | | |--ELIST -> ELIST [2475:40]
28734 | | | `--EXPR -> EXPR [2475:40]
28735 | | | `--STRING_LITERAL -> "InputIndentationCustomAnnotation.java" [2475:40]
28736 | | `--RPAREN -> ) [2475:79]
28737 | |--SEMI -> ; [2475:80]
28738 | |--VARIABLE_DEF -> VARIABLE_DEF [2476:8]
28739 | | |--MODIFIERS -> MODIFIERS [2476:8]
28740 | | | `--FINAL -> final [2476:8]
28741 | | |--TYPE -> TYPE [2476:20]
28742 | | | `--ARRAY_DECLARATOR -> [ [2476:20]
28743 | | | |--IDENT -> String [2476:14]
28744 | | | `--RBRACK -> ] [2476:21]
28745 | | |--IDENT -> expected [2476:23]
28746 | | `--ASSIGN -> = [2476:32]
28747 | | `--ARRAY_INIT -> { [2476:34]
28748 | | |--EXPR -> EXPR [2477:21]
28749 | | | `--PLUS -> + [2477:21]
28750 | | | |--STRING_LITERAL -> "14:6: " [2477:12]
28751 | | | `--METHOD_CALL -> ( [2477:38]
28752 | | | |--IDENT -> getCheckMessage [2477:23]
28753 | | | |--ELIST -> ELIST [2477:39]
28754 | | | | |--EXPR -> EXPR [2477:39]
28755 | | | | | `--IDENT -> MSG_ERROR [2477:39]
28756 | | | | |--COMMA -> , [2477:48]
28757 | | | | |--EXPR -> EXPR [2477:50]
28758 | | | | | `--STRING_LITERAL -> "annotation def modifier" [2477:50]
28759 | | | | |--COMMA -> , [2477:75]
28760 | | | | |--EXPR -> EXPR [2477:77]
28761 | | | | | `--NUM_INT -> 5 [2477:77]
28762 | | | | |--COMMA -> , [2477:78]
28763 | | | | `--EXPR -> EXPR [2477:80]
28764 | | | | `--NUM_INT -> 0 [2477:80]
28765 | | | `--RPAREN -> ) [2477:81]
28766 | | |--COMMA -> , [2477:82]
28767 | | |--EXPR -> EXPR [2478:21]
28768 | | | `--PLUS -> + [2478:21]
28769 | | | |--STRING_LITERAL -> "15:6: " [2478:12]
28770 | | | `--METHOD_CALL -> ( [2478:38]
28771 | | | |--IDENT -> getCheckMessage [2478:23]
28772 | | | |--ELIST -> ELIST [2478:39]
28773 | | | | |--EXPR -> EXPR [2478:39]
28774 | | | | | `--IDENT -> MSG_ERROR [2478:39]
28775 | | | | |--COMMA -> , [2478:48]
28776 | | | | |--EXPR -> EXPR [2478:50]
28777 | | | | | `--STRING_LITERAL -> "annotation def rcurly" [2478:50]
28778 | | | | |--COMMA -> , [2478:73]
28779 | | | | |--EXPR -> EXPR [2478:75]
28780 | | | | | `--NUM_INT -> 5 [2478:75]
28781 | | | | |--COMMA -> , [2478:76]
28782 | | | | `--EXPR -> EXPR [2478:78]
28783 | | | | `--NUM_INT -> 0 [2478:78]
28784 | | | `--RPAREN -> ) [2478:79]
28785 | | |--COMMA -> , [2478:80]
28786 | | |--EXPR -> EXPR [2479:21]
28787 | | | `--PLUS -> + [2479:21]
28788 | | | |--STRING_LITERAL -> "16:6: " [2479:12]
28789 | | | `--METHOD_CALL -> ( [2479:38]
28790 | | | |--IDENT -> getCheckMessage [2479:23]
28791 | | | |--ELIST -> ELIST [2479:39]
28792 | | | | |--EXPR -> EXPR [2479:39]
28793 | | | | | `--IDENT -> MSG_ERROR [2479:39]
28794 | | | | |--COMMA -> , [2479:48]
28795 | | | | |--EXPR -> EXPR [2479:50]
28796 | | | | | `--STRING_LITERAL -> "@" [2479:50]
28797 | | | | |--COMMA -> , [2479:53]
28798 | | | | |--EXPR -> EXPR [2479:55]
28799 | | | | | `--NUM_INT -> 5 [2479:55]
28800 | | | | |--COMMA -> , [2479:56]
28801 | | | | `--EXPR -> EXPR [2479:58]
28802 | | | | `--NUM_INT -> 0 [2479:58]
28803 | | | `--RPAREN -> ) [2479:59]
28804 | | |--COMMA -> , [2479:60]
28805 | | |--EXPR -> EXPR [2480:21]
28806 | | | `--PLUS -> + [2480:21]
28807 | | | |--STRING_LITERAL -> "17:1: " [2480:12]
28808 | | | `--METHOD_CALL -> ( [2480:38]
28809 | | | |--IDENT -> getCheckMessage [2480:23]
28810 | | | |--ELIST -> ELIST [2480:39]
28811 | | | | |--EXPR -> EXPR [2480:39]
28812 | | | | | `--IDENT -> MSG_ERROR [2480:39]
28813 | | | | |--COMMA -> , [2480:48]
28814 | | | | |--EXPR -> EXPR [2480:50]
28815 | | | | | `--STRING_LITERAL -> "annotation field def modifier" [2480:50]
28816 | | | | |--COMMA -> , [2480:81]
28817 | | | | |--EXPR -> EXPR [2480:83]
28818 | | | | | `--NUM_INT -> 0 [2480:83]
28819 | | | | |--COMMA -> , [2480:84]
28820 | | | | `--EXPR -> EXPR [2480:86]
28821 | | | | `--NUM_INT -> 4 [2480:86]
28822 | | | `--RPAREN -> ) [2480:87]
28823 | | |--COMMA -> , [2480:88]
28824 | | |--EXPR -> EXPR [2481:21]
28825 | | | `--PLUS -> + [2481:21]
28826 | | | |--STRING_LITERAL -> "18:6: " [2481:12]
28827 | | | `--METHOD_CALL -> ( [2481:38]
28828 | | | |--IDENT -> getCheckMessage [2481:23]
28829 | | | |--ELIST -> ELIST [2481:39]
28830 | | | | |--EXPR -> EXPR [2481:39]
28831 | | | | | `--IDENT -> MSG_ERROR [2481:39]
28832 | | | | |--COMMA -> , [2481:48]
28833 | | | | |--EXPR -> EXPR [2481:50]
28834 | | | | | `--STRING_LITERAL -> "annotation def rcurly" [2481:50]
28835 | | | | |--COMMA -> , [2481:73]
28836 | | | | |--EXPR -> EXPR [2481:75]
28837 | | | | | `--NUM_INT -> 5 [2481:75]
28838 | | | | |--COMMA -> , [2481:76]
28839 | | | | `--EXPR -> EXPR [2481:78]
28840 | | | | `--NUM_INT -> 0 [2481:78]
28841 | | | `--RPAREN -> ) [2481:79]
28842 | | |--COMMA -> , [2481:80]
28843 | | |--EXPR -> EXPR [2482:21]
28844 | | | `--PLUS -> + [2482:21]
28845 | | | |--STRING_LITERAL -> "20:4: " [2482:12]
28846 | | | `--METHOD_CALL -> ( [2482:38]
28847 | | | |--IDENT -> getCheckMessage [2482:23]
28848 | | | |--ELIST -> ELIST [2482:39]
28849 | | | | |--EXPR -> EXPR [2482:39]
28850 | | | | | `--IDENT -> MSG_ERROR [2482:39]
28851 | | | | |--COMMA -> , [2482:48]
28852 | | | | |--EXPR -> EXPR [2482:50]
28853 | | | | | `--STRING_LITERAL -> "annotation def modifier" [2482:50]
28854 | | | | |--COMMA -> , [2482:75]
28855 | | | | |--EXPR -> EXPR [2482:77]
28856 | | | | | `--NUM_INT -> 3 [2482:77]
28857 | | | | |--COMMA -> , [2482:78]
28858 | | | | `--EXPR -> EXPR [2482:80]
28859 | | | | `--NUM_INT -> 0 [2482:80]
28860 | | | `--RPAREN -> ) [2482:81]
28861 | | |--COMMA -> , [2482:82]
28862 | | |--EXPR -> EXPR [2483:21]
28863 | | | `--PLUS -> + [2483:21]
28864 | | | |--STRING_LITERAL -> "22:1: " [2483:12]
28865 | | | `--METHOD_CALL -> ( [2483:38]
28866 | | | |--IDENT -> getCheckMessage [2483:23]
28867 | | | |--ELIST -> ELIST [2483:39]
28868 | | | | |--EXPR -> EXPR [2483:39]
28869 | | | | | `--IDENT -> MSG_ERROR [2483:39]
28870 | | | | |--COMMA -> , [2483:48]
28871 | | | | |--EXPR -> EXPR [2483:50]
28872 | | | | | `--STRING_LITERAL -> "annotation field def modifier" [2483:50]
28873 | | | | |--COMMA -> , [2483:81]
28874 | | | | |--EXPR -> EXPR [2483:83]
28875 | | | | | `--NUM_INT -> 0 [2483:83]
28876 | | | | |--COMMA -> , [2483:84]
28877 | | | | `--EXPR -> EXPR [2483:86]
28878 | | | | `--NUM_INT -> 4 [2483:86]
28879 | | | `--RPAREN -> ) [2483:87]
28880 | | |--COMMA -> , [2483:88]
28881 | | |--EXPR -> EXPR [2484:21]
28882 | | | `--PLUS -> + [2484:21]
28883 | | | |--STRING_LITERAL -> "23:6: " [2484:12]
28884 | | | `--METHOD_CALL -> ( [2484:38]
28885 | | | |--IDENT -> getCheckMessage [2484:23]
28886 | | | |--ELIST -> ELIST [2484:39]
28887 | | | | |--EXPR -> EXPR [2484:39]
28888 | | | | | `--IDENT -> MSG_ERROR [2484:39]
28889 | | | | |--COMMA -> , [2484:48]
28890 | | | | |--EXPR -> EXPR [2484:50]
28891 | | | | | `--STRING_LITERAL -> "annotation def rcurly" [2484:50]
28892 | | | | |--COMMA -> , [2484:73]
28893 | | | | |--EXPR -> EXPR [2484:75]
28894 | | | | | `--NUM_INT -> 5 [2484:75]
28895 | | | | |--COMMA -> , [2484:76]
28896 | | | | `--EXPR -> EXPR [2484:78]
28897 | | | | `--NUM_INT -> 0 [2484:78]
28898 | | | `--RPAREN -> ) [2484:79]
28899 | | |--COMMA -> , [2484:80]
28900 | | |--EXPR -> EXPR [2485:21]
28901 | | | `--PLUS -> + [2485:21]
28902 | | | |--STRING_LITERAL -> "25:6: " [2485:12]
28903 | | | `--METHOD_CALL -> ( [2485:38]
28904 | | | |--IDENT -> getCheckMessage [2485:23]
28905 | | | |--ELIST -> ELIST [2485:39]
28906 | | | | |--EXPR -> EXPR [2485:39]
28907 | | | | | `--IDENT -> MSG_ERROR [2485:39]
28908 | | | | |--COMMA -> , [2485:48]
28909 | | | | |--EXPR -> EXPR [2485:50]
28910 | | | | | `--STRING_LITERAL -> "@" [2485:50]
28911 | | | | |--COMMA -> , [2485:53]
28912 | | | | |--EXPR -> EXPR [2485:55]
28913 | | | | | `--NUM_INT -> 5 [2485:55]
28914 | | | | |--COMMA -> , [2485:56]
28915 | | | | `--EXPR -> EXPR [2485:58]
28916 | | | | `--NUM_INT -> 0 [2485:58]
28917 | | | `--RPAREN -> ) [2485:59]
28918 | | |--COMMA -> , [2485:60]
28919 | | |--EXPR -> EXPR [2486:21]
28920 | | | `--PLUS -> + [2486:21]
28921 | | | |--STRING_LITERAL -> "26:6: " [2486:12]
28922 | | | `--METHOD_CALL -> ( [2486:38]
28923 | | | |--IDENT -> getCheckMessage [2486:23]
28924 | | | |--ELIST -> ELIST [2486:39]
28925 | | | | |--EXPR -> EXPR [2486:39]
28926 | | | | | `--IDENT -> MSG_ERROR [2486:39]
28927 | | | | |--COMMA -> , [2486:48]
28928 | | | | |--EXPR -> EXPR [2486:50]
28929 | | | | | `--STRING_LITERAL -> "AnnotationWithLineWrap" [2486:50]
28930 | | | | |--COMMA -> , [2486:74]
28931 | | | | |--EXPR -> EXPR [2486:76]
28932 | | | | | `--NUM_INT -> 5 [2486:76]
28933 | | | | |--COMMA -> , [2486:77]
28934 | | | | `--EXPR -> EXPR [2486:79]
28935 | | | | `--NUM_INT -> 0 [2486:79]
28936 | | | `--RPAREN -> ) [2486:80]
28937 | | |--COMMA -> , [2486:81]
28938 | | |--EXPR -> EXPR [2487:21]
28939 | | | `--PLUS -> + [2487:21]
28940 | | | |--STRING_LITERAL -> "30:6: " [2487:12]
28941 | | | `--METHOD_CALL -> ( [2487:38]
28942 | | | |--IDENT -> getCheckMessage [2487:23]
28943 | | | |--ELIST -> ELIST [2487:39]
28944 | | | | |--EXPR -> EXPR [2487:39]
28945 | | | | | `--IDENT -> MSG_ERROR [2487:39]
28946 | | | | |--COMMA -> , [2487:48]
28947 | | | | |--EXPR -> EXPR [2487:50]
28948 | | | | | `--STRING_LITERAL -> "annotation def modifier" [2487:50]
28949 | | | | |--COMMA -> , [2487:75]
28950 | | | | |--EXPR -> EXPR [2487:77]
28951 | | | | | `--NUM_INT -> 5 [2487:77]
28952 | | | | |--COMMA -> , [2487:78]
28953 | | | | `--EXPR -> EXPR [2487:80]
28954 | | | | `--NUM_INT -> 0 [2487:80]
28955 | | | `--RPAREN -> ) [2487:81]
28956 | | |--COMMA -> , [2487:82]
28957 | | |--EXPR -> EXPR [2488:21]
28958 | | | `--PLUS -> + [2488:21]
28959 | | | |--STRING_LITERAL -> "31:4: " [2488:12]
28960 | | | `--METHOD_CALL -> ( [2488:38]
28961 | | | |--IDENT -> getCheckMessage [2488:23]
28962 | | | |--ELIST -> ELIST [2488:39]
28963 | | | | |--EXPR -> EXPR [2488:39]
28964 | | | | | `--IDENT -> MSG_ERROR [2488:39]
28965 | | | | |--COMMA -> , [2488:48]
28966 | | | | |--EXPR -> EXPR [2488:50]
28967 | | | | | `--STRING_LITERAL -> "annotation def modifier" [2488:50]
28968 | | | | |--COMMA -> , [2488:75]
28969 | | | | |--EXPR -> EXPR [2488:77]
28970 | | | | | `--NUM_INT -> 3 [2488:77]
28971 | | | | |--COMMA -> , [2488:78]
28972 | | | | `--EXPR -> EXPR [2488:80]
28973 | | | | `--NUM_INT -> 0 [2488:80]
28974 | | | `--RPAREN -> ) [2488:81]
28975 | | |--COMMA -> , [2488:82]
28976 | | |--EXPR -> EXPR [2489:21]
28977 | | | `--PLUS -> + [2489:21]
28978 | | | |--STRING_LITERAL -> "34:6: " [2489:12]
28979 | | | `--METHOD_CALL -> ( [2489:38]
28980 | | | |--IDENT -> getCheckMessage [2489:23]
28981 | | | |--ELIST -> ELIST [2489:39]
28982 | | | | |--EXPR -> EXPR [2489:39]
28983 | | | | | `--IDENT -> MSG_ERROR [2489:39]
28984 | | | | |--COMMA -> , [2489:48]
28985 | | | | |--EXPR -> EXPR [2489:50]
28986 | | | | | `--STRING_LITERAL -> "annotation field def modifier" [2489:50]
28987 | | | | |--COMMA -> , [2489:81]
28988 | | | | |--EXPR -> EXPR [2489:83]
28989 | | | | | `--NUM_INT -> 5 [2489:83]
28990 | | | | |--COMMA -> , [2489:84]
28991 | | | | `--EXPR -> EXPR [2489:86]
28992 | | | | `--NUM_INT -> 4 [2489:86]
28993 | | | `--RPAREN -> ) [2489:87]
28994 | | |--COMMA -> , [2489:88]
28995 | | |--EXPR -> EXPR [2490:21]
28996 | | | `--PLUS -> + [2490:21]
28997 | | | |--STRING_LITERAL -> "35:4: " [2490:12]
28998 | | | `--METHOD_CALL -> ( [2490:38]
28999 | | | |--IDENT -> getCheckMessage [2490:23]
29000 | | | |--ELIST -> ELIST [2490:39]
29001 | | | | |--EXPR -> EXPR [2490:39]
29002 | | | | | `--IDENT -> MSG_ERROR [2490:39]
29003 | | | | |--COMMA -> , [2490:48]
29004 | | | | |--EXPR -> EXPR [2490:50]
29005 | | | | | `--STRING_LITERAL -> "annotation def modifier" [2490:50]
29006 | | | | |--COMMA -> , [2490:75]
29007 | | | | |--EXPR -> EXPR [2490:77]
29008 | | | | | `--NUM_INT -> 3 [2490:77]
29009 | | | | |--COMMA -> , [2490:78]
29010 | | | | `--EXPR -> EXPR [2490:80]
29011 | | | | `--NUM_INT -> 4 [2490:80]
29012 | | | `--RPAREN -> ) [2490:81]
29013 | | |--COMMA -> , [2490:82]
29014 | | |--EXPR -> EXPR [2491:21]
29015 | | | `--PLUS -> + [2491:21]
29016 | | | |--STRING_LITERAL -> "36:1: " [2491:12]
29017 | | | `--METHOD_CALL -> ( [2491:38]
29018 | | | |--IDENT -> getCheckMessage [2491:23]
29019 | | | |--ELIST -> ELIST [2491:39]
29020 | | | | |--EXPR -> EXPR [2491:39]
29021 | | | | | `--IDENT -> MSG_ERROR [2491:39]
29022 | | | | |--COMMA -> , [2491:48]
29023 | | | | |--EXPR -> EXPR [2491:50]
29024 | | | | | `--STRING_LITERAL -> "annotation def modifier" [2491:50]
29025 | | | | |--COMMA -> , [2491:75]
29026 | | | | |--EXPR -> EXPR [2491:77]
29027 | | | | | `--NUM_INT -> 0 [2491:77]
29028 | | | | |--COMMA -> , [2491:78]
29029 | | | | `--EXPR -> EXPR [2491:80]
29030 | | | | `--NUM_INT -> 4 [2491:80]
29031 | | | `--RPAREN -> ) [2491:81]
29032 | | |--COMMA -> , [2491:82]
29033 | | |--EXPR -> EXPR [2492:21]
29034 | | | `--PLUS -> + [2492:21]
29035 | | | |--STRING_LITERAL -> "37:1: " [2492:12]
29036 | | | `--METHOD_CALL -> ( [2492:38]
29037 | | | |--IDENT -> getCheckMessage [2492:23]
29038 | | | |--ELIST -> ELIST [2492:39]
29039 | | | | |--EXPR -> EXPR [2492:39]
29040 | | | | | `--IDENT -> MSG_ERROR [2492:39]
29041 | | | | |--COMMA -> , [2492:48]
29042 | | | | |--EXPR -> EXPR [2492:50]
29043 | | | | | `--STRING_LITERAL -> "@" [2492:50]
29044 | | | | |--COMMA -> , [2492:53]
29045 | | | | |--EXPR -> EXPR [2492:55]
29046 | | | | | `--NUM_INT -> 0 [2492:55]
29047 | | | | |--COMMA -> , [2492:56]
29048 | | | | `--EXPR -> EXPR [2492:58]
29049 | | | | `--NUM_INT -> 4 [2492:58]
29050 | | | `--RPAREN -> ) [2492:59]
29051 | | |--COMMA -> , [2492:60]
29052 | | |--EXPR -> EXPR [2493:21]
29053 | | | `--PLUS -> + [2493:21]
29054 | | | |--STRING_LITERAL -> "38:9: " [2493:12]
29055 | | | `--METHOD_CALL -> ( [2493:38]
29056 | | | |--IDENT -> getCheckMessage [2493:23]
29057 | | | |--ELIST -> ELIST [2493:39]
29058 | | | | |--EXPR -> EXPR [2493:39]
29059 | | | | | `--IDENT -> MSG_ERROR [2493:39]
29060 | | | | |--COMMA -> , [2493:48]
29061 | | | | |--EXPR -> EXPR [2493:50]
29062 | | | | | `--STRING_LITERAL -> "AnnotationInnerLineWrap" [2493:50]
29063 | | | | |--COMMA -> , [2493:75]
29064 | | | | |--EXPR -> EXPR [2493:77]
29065 | | | | | `--NUM_INT -> 8 [2493:77]
29066 | | | | |--COMMA -> , [2493:78]
29067 | | | | `--EXPR -> EXPR [2493:80]
29068 | | | | `--NUM_INT -> 4 [2493:80]
29069 | | | `--RPAREN -> ) [2493:81]
29070 | | |--COMMA -> , [2493:82]
29071 | | |--EXPR -> EXPR [2494:21]
29072 | | | `--PLUS -> + [2494:21]
29073 | | | |--STRING_LITERAL -> "41:8: " [2494:12]
29074 | | | `--METHOD_CALL -> ( [2494:38]
29075 | | | |--IDENT -> getCheckMessage [2494:23]
29076 | | | |--ELIST -> ELIST [2494:39]
29077 | | | | |--EXPR -> EXPR [2494:39]
29078 | | | | | `--IDENT -> MSG_ERROR [2494:39]
29079 | | | | |--COMMA -> , [2494:48]
29080 | | | | |--EXPR -> EXPR [2494:50]
29081 | | | | | `--STRING_LITERAL -> "annotation field def modifier" [2494:50]
29082 | | | | |--COMMA -> , [2494:81]
29083 | | | | |--EXPR -> EXPR [2494:83]
29084 | | | | | `--NUM_INT -> 7 [2494:83]
29085 | | | | |--COMMA -> , [2494:84]
29086 | | | | `--EXPR -> EXPR [2494:86]
29087 | | | | `--NUM_INT -> 8 [2494:86]
29088 | | | `--RPAREN -> ) [2494:87]
29089 | | |--COMMA -> , [2494:88]
29090 | | |--EXPR -> EXPR [2495:21]
29091 | | | `--PLUS -> + [2495:21]
29092 | | | |--STRING_LITERAL -> "58:5: " [2495:12]
29093 | | | `--METHOD_CALL -> ( [2495:38]
29094 | | | |--IDENT -> getCheckMessage [2495:23]
29095 | | | |--ELIST -> ELIST [2495:39]
29096 | | | | |--EXPR -> EXPR [2495:39]
29097 | | | | | `--IDENT -> MSG_ERROR [2495:39]
29098 | | | | |--COMMA -> , [2495:48]
29099 | | | | |--EXPR -> EXPR [2495:50]
29100 | | | | | `--STRING_LITERAL -> "AnnotationInnerLineWrap2" [2495:50]
29101 | | | | |--COMMA -> , [2495:76]
29102 | | | | |--EXPR -> EXPR [2495:78]
29103 | | | | | `--NUM_INT -> 4 [2495:78]
29104 | | | | |--COMMA -> , [2495:79]
29105 | | | | `--EXPR -> EXPR [2495:81]
29106 | | | | `--NUM_INT -> 0 [2495:81]
29107 | | | `--RPAREN -> ) [2495:82]
29108 | | |--COMMA -> , [2495:83]
29109 | | |--EXPR -> EXPR [2496:21]
29110 | | | `--PLUS -> + [2496:21]
29111 | | | |--STRING_LITERAL -> "59:4: " [2496:12]
29112 | | | `--METHOD_CALL -> ( [2496:38]
29113 | | | |--IDENT -> getCheckMessage [2496:23]
29114 | | | |--ELIST -> ELIST [2496:39]
29115 | | | | |--EXPR -> EXPR [2496:39]
29116 | | | | | `--IDENT -> MSG_ERROR [2496:39]
29117 | | | | |--COMMA -> , [2496:48]
29118 | | | | |--EXPR -> EXPR [2496:50]
29119 | | | | | `--STRING_LITERAL -> "annotation field def modifier" [2496:50]
29120 | | | | |--COMMA -> , [2496:81]
29121 | | | | |--EXPR -> EXPR [2496:83]
29122 | | | | | `--NUM_INT -> 3 [2496:83]
29123 | | | | |--COMMA -> , [2496:84]
29124 | | | | `--EXPR -> EXPR [2496:86]
29125 | | | | `--NUM_INT -> 4 [2496:86]
29126 | | | `--RPAREN -> ) [2496:87]
29127 | | |--COMMA -> , [2496:88]
29128 | | |--EXPR -> EXPR [2497:21]
29129 | | | `--PLUS -> + [2497:21]
29130 | | | |--STRING_LITERAL -> "60:8: " [2497:12]
29131 | | | `--METHOD_CALL -> ( [2497:38]
29132 | | | |--IDENT -> getCheckMessage [2497:23]
29133 | | | |--ELIST -> ELIST [2497:39]
29134 | | | | |--EXPR -> EXPR [2497:39]
29135 | | | | | `--IDENT -> MSG_ERROR [2497:39]
29136 | | | | |--COMMA -> , [2497:48]
29137 | | | | |--EXPR -> EXPR [2497:50]
29138 | | | | | `--STRING_LITERAL -> "annotation field def modifier" [2497:50]
29139 | | | | |--COMMA -> , [2497:81]
29140 | | | | |--EXPR -> EXPR [2497:83]
29141 | | | | | `--NUM_INT -> 7 [2497:83]
29142 | | | | |--COMMA -> , [2497:84]
29143 | | | | `--EXPR -> EXPR [2497:86]
29144 | | | | `--NUM_INT -> 4 [2497:86]
29145 | | | `--RPAREN -> ) [2497:87]
29146 | | |--COMMA -> , [2497:88]
29147 | | |--EXPR -> EXPR [2498:21]
29148 | | | `--PLUS -> + [2498:21]
29149 | | | |--STRING_LITERAL -> "61:5: " [2498:12]
29150 | | | `--METHOD_CALL -> ( [2498:38]
29151 | | | |--IDENT -> getCheckMessage [2498:23]
29152 | | | |--ELIST -> ELIST [2498:39]
29153 | | | | |--EXPR -> EXPR [2498:39]
29154 | | | | | `--IDENT -> MSG_ERROR [2498:39]
29155 | | | | |--COMMA -> , [2498:48]
29156 | | | | |--EXPR -> EXPR [2498:50]
29157 | | | | | `--STRING_LITERAL -> "annotation def rcurly" [2498:50]
29158 | | | | |--COMMA -> , [2498:73]
29159 | | | | |--EXPR -> EXPR [2498:75]
29160 | | | | | `--NUM_INT -> 4 [2498:75]
29161 | | | | |--COMMA -> , [2498:76]
29162 | | | | `--EXPR -> EXPR [2498:78]
29163 | | | | `--NUM_INT -> 0 [2498:78]
29164 | | | `--RPAREN -> ) [2498:79]
29165 | | |--COMMA -> , [2498:80]
29166 | | |--EXPR -> EXPR [2499:21]
29167 | | | `--PLUS -> + [2499:21]
29168 | | | |--STRING_LITERAL -> "72:4: " [2499:12]
29169 | | | `--METHOD_CALL -> ( [2499:38]
29170 | | | |--IDENT -> getCheckMessage [2499:23]
29171 | | | |--ELIST -> ELIST [2499:39]
29172 | | | | |--EXPR -> EXPR [2499:39]
29173 | | | | | `--IDENT -> MSG_ERROR [2499:39]
29174 | | | | |--COMMA -> , [2499:48]
29175 | | | | |--EXPR -> EXPR [2499:50]
29176 | | | | | `--STRING_LITERAL -> "annotation def modifier" [2499:50]
29177 | | | | |--COMMA -> , [2499:75]
29178 | | | | |--EXPR -> EXPR [2499:77]
29179 | | | | | `--NUM_INT -> 3 [2499:77]
29180 | | | | |--COMMA -> , [2499:78]
29181 | | | | `--EXPR -> EXPR [2499:80]
29182 | | | | `--NUM_INT -> 4 [2499:80]
29183 | | | `--RPAREN -> ) [2499:81]
29184 | | |--COMMA -> , [2499:82]
29185 | | |--EXPR -> EXPR [2500:22]
29186 | | | `--PLUS -> + [2500:22]
29187 | | | |--STRING_LITERAL -> "87:29: " [2500:12]
29188 | | | `--METHOD_CALL -> ( [2500:39]
29189 | | | |--IDENT -> getCheckMessage [2500:24]
29190 | | | |--ELIST -> ELIST [2500:40]
29191 | | | | |--EXPR -> EXPR [2500:40]
29192 | | | | | `--IDENT -> MSG_ERROR_MULTI [2500:40]
29193 | | | | |--COMMA -> , [2500:55]
29194 | | | | |--EXPR -> EXPR [2500:57]
29195 | | | | | `--STRING_LITERAL -> "new" [2500:57]
29196 | | | | |--COMMA -> , [2500:62]
29197 | | | | |--EXPR -> EXPR [2500:64]
29198 | | | | | `--NUM_INT -> 28 [2500:64]
29199 | | | | |--COMMA -> , [2500:66]
29200 | | | | `--EXPR -> EXPR [2500:68]
29201 | | | | `--STRING_LITERAL -> "20, 24" [2500:68]
29202 | | | `--RPAREN -> ) [2500:76]
29203 | | |--COMMA -> , [2500:77]
29204 | | |--EXPR -> EXPR [2501:22]
29205 | | | `--PLUS -> + [2501:22]
29206 | | | |--STRING_LITERAL -> "117:6: " [2501:12]
29207 | | | `--METHOD_CALL -> ( [2501:39]
29208 | | | |--IDENT -> getCheckMessage [2501:24]
29209 | | | |--ELIST -> ELIST [2501:40]
29210 | | | | |--EXPR -> EXPR [2501:40]
29211 | | | | | `--IDENT -> MSG_ERROR [2501:40]
29212 | | | | |--COMMA -> , [2501:49]
29213 | | | | |--EXPR -> EXPR [2501:51]
29214 | | | | | `--STRING_LITERAL -> "annotation def modifier" [2501:51]
29215 | | | | |--COMMA -> , [2501:76]
29216 | | | | |--EXPR -> EXPR [2501:78]
29217 | | | | | `--NUM_INT -> 5 [2501:78]
29218 | | | | |--COMMA -> , [2501:79]
29219 | | | | `--EXPR -> EXPR [2501:81]
29220 | | | | `--NUM_INT -> 4 [2501:81]
29221 | | | `--RPAREN -> ) [2501:82]
29222 | | |--COMMA -> , [2501:83]
29223 | | |--EXPR -> EXPR [2502:22]
29224 | | | `--PLUS -> + [2502:22]
29225 | | | |--STRING_LITERAL -> "128:2: " [2502:12]
29226 | | | `--METHOD_CALL -> ( [2502:39]
29227 | | | |--IDENT -> getCheckMessage [2502:24]
29228 | | | |--ELIST -> ELIST [2502:40]
29229 | | | | |--EXPR -> EXPR [2502:40]
29230 | | | | | `--IDENT -> MSG_ERROR [2502:40]
29231 | | | | |--COMMA -> , [2502:49]
29232 | | | | |--EXPR -> EXPR [2502:51]
29233 | | | | | `--STRING_LITERAL -> "interface" [2502:51]
29234 | | | | |--COMMA -> , [2502:62]
29235 | | | | |--EXPR -> EXPR [2502:64]
29236 | | | | | `--NUM_INT -> 1 [2502:64]
29237 | | | | |--COMMA -> , [2502:65]
29238 | | | | `--EXPR -> EXPR [2502:67]
29239 | | | | `--NUM_INT -> 0 [2502:67]
29240 | | | `--RPAREN -> ) [2502:68]
29241 | | |--COMMA -> , [2502:69]
29242 | | |--EXPR -> EXPR [2503:23]
29243 | | | `--PLUS -> + [2503:23]
29244 | | | |--STRING_LITERAL -> "134:12: " [2503:12]
29245 | | | `--METHOD_CALL -> ( [2503:40]
29246 | | | |--IDENT -> getCheckMessage [2503:25]
29247 | | | |--ELIST -> ELIST [2503:41]
29248 | | | | |--EXPR -> EXPR [2503:41]
29249 | | | | | `--IDENT -> MSG_ERROR [2503:41]
29250 | | | | |--COMMA -> , [2503:50]
29251 | | | | |--EXPR -> EXPR [2503:52]
29252 | | | | | `--STRING_LITERAL -> "@" [2503:52]
29253 | | | | |--COMMA -> , [2503:55]
29254 | | | | |--EXPR -> EXPR [2503:57]
29255 | | | | | `--NUM_INT -> 11 [2503:57]
29256 | | | | |--COMMA -> , [2503:59]
29257 | | | | `--EXPR -> EXPR [2503:61]
29258 | | | | `--NUM_INT -> 0 [2503:61]
29259 | | | `--RPAREN -> ) [2503:62]
29260 | | |--COMMA -> , [2503:63]
29261 | | |--EXPR -> EXPR [2504:23]
29262 | | | `--PLUS -> + [2504:23]
29263 | | | |--STRING_LITERAL -> "137:17: " [2504:12]
29264 | | | `--METHOD_CALL -> ( [2504:40]
29265 | | | |--IDENT -> getCheckMessage [2504:25]
29266 | | | |--ELIST -> ELIST [2504:41]
29267 | | | | |--EXPR -> EXPR [2504:41]
29268 | | | | | `--IDENT -> MSG_ERROR [2504:41]
29269 | | | | |--COMMA -> , [2504:50]
29270 | | | | |--EXPR -> EXPR [2504:52]
29271 | | | | | `--STRING_LITERAL -> "@" [2504:52]
29272 | | | | |--COMMA -> , [2504:55]
29273 | | | | |--EXPR -> EXPR [2504:57]
29274 | | | | | `--NUM_INT -> 16 [2504:57]
29275 | | | | |--COMMA -> , [2504:59]
29276 | | | | `--EXPR -> EXPR [2504:61]
29277 | | | | `--NUM_INT -> 0 [2504:61]
29278 | | | `--RPAREN -> ) [2504:62]
29279 | | |--COMMA -> , [2504:63]
29280 | | |--EXPR -> EXPR [2505:23]
29281 | | | `--PLUS -> + [2505:23]
29282 | | | |--STRING_LITERAL -> "144:13: " [2505:12]
29283 | | | `--METHOD_CALL -> ( [2505:40]
29284 | | | |--IDENT -> getCheckMessage [2505:25]
29285 | | | |--ELIST -> ELIST [2505:41]
29286 | | | | |--EXPR -> EXPR [2505:41]
29287 | | | | | `--IDENT -> MSG_ERROR [2505:41]
29288 | | | | |--COMMA -> , [2505:50]
29289 | | | | |--EXPR -> EXPR [2505:52]
29290 | | | | | `--STRING_LITERAL -> "@" [2505:52]
29291 | | | | |--COMMA -> , [2505:55]
29292 | | | | |--EXPR -> EXPR [2505:57]
29293 | | | | | `--NUM_INT -> 12 [2505:57]
29294 | | | | |--COMMA -> , [2505:59]
29295 | | | | `--EXPR -> EXPR [2505:61]
29296 | | | | `--NUM_INT -> 4 [2505:61]
29297 | | | `--RPAREN -> ) [2505:62]
29298 | | |--COMMA -> , [2505:63]
29299 | | |--EXPR -> EXPR [2506:23]
29300 | | | `--PLUS -> + [2506:23]
29301 | | | |--STRING_LITERAL -> "148:23: " [2506:12]
29302 | | | `--METHOD_CALL -> ( [2506:40]
29303 | | | |--IDENT -> getCheckMessage [2506:25]
29304 | | | |--ELIST -> ELIST [2506:41]
29305 | | | | |--EXPR -> EXPR [2506:41]
29306 | | | | | `--IDENT -> MSG_ERROR [2506:41]
29307 | | | | |--COMMA -> , [2506:50]
29308 | | | | |--EXPR -> EXPR [2506:52]
29309 | | | | | `--STRING_LITERAL -> "class def ident" [2506:52]
29310 | | | | |--COMMA -> , [2506:69]
29311 | | | | |--EXPR -> EXPR [2506:71]
29312 | | | | | `--NUM_INT -> 16 [2506:71]
29313 | | | | |--COMMA -> , [2506:73]
29314 | | | | `--EXPR -> EXPR [2506:75]
29315 | | | | `--NUM_INT -> 0 [2506:75]
29316 | | | `--RPAREN -> ) [2506:76]
29317 | | |--COMMA -> , [2506:77]
29318 | | `--RCURLY -> } [2507:8]
29319 | |--SEMI -> ; [2507:9]
29320 | |--EXPR -> EXPR [2508:19]
29321 | | `--METHOD_CALL -> ( [2508:19]
29322 | | |--IDENT -> verifyWarns [2508:8]
29323 | | |--ELIST -> ELIST [2508:20]
29324 | | | |--EXPR -> EXPR [2508:20]
29325 | | | | `--IDENT -> checkConfig [2508:20]
29326 | | | |--COMMA -> , [2508:31]
29327 | | | |--EXPR -> EXPR [2508:33]
29328 | | | | `--IDENT -> fileName [2508:33]
29329 | | | |--COMMA -> , [2508:41]
29330 | | | `--EXPR -> EXPR [2508:43]
29331 | | | `--IDENT -> expected [2508:43]
29332 | | `--RPAREN -> ) [2508:51]
29333 | |--SEMI -> ; [2508:52]
29334 | `--RCURLY -> } [2509:4]
29335 |--METHOD_DEF -> METHOD_DEF [2511:4]
29336 | |--MODIFIERS -> MODIFIERS [2511:4]
29337 | | |--ANNOTATION -> ANNOTATION [2511:4]
29338 | | | |--AT -> @ [2511:4]
29339 | | | `--IDENT -> Test [2511:5]
29340 | | `--LITERAL_PUBLIC -> public [2512:4]
29341 | |--TYPE -> TYPE [2512:11]
29342 | | `--LITERAL_VOID -> void [2512:11]
29343 | |--IDENT -> testTryResourcesStrict [2512:16]
29344 | |--LPAREN -> ( [2512:38]
29345 | |--PARAMETERS -> PARAMETERS [2512:39]
29346 | |--RPAREN -> ) [2512:39]
29347 | |--LITERAL_THROWS -> throws [2512:41]
29348 | | `--IDENT -> Exception [2512:48]
29349 | `--SLIST -> { [2512:58]
29350 | |--VARIABLE_DEF -> VARIABLE_DEF [2513:8]
29351 | | |--MODIFIERS -> MODIFIERS [2513:8]
29352 | | | `--FINAL -> final [2513:8]
29353 | | |--TYPE -> TYPE [2513:14]
29354 | | | `--IDENT -> DefaultConfiguration [2513:14]
29355 | | |--IDENT -> checkConfig [2513:35]
29356 | | `--ASSIGN -> = [2513:47]
29357 | | `--EXPR -> EXPR [2513:67]
29358 | | `--METHOD_CALL -> ( [2513:67]
29359 | | |--IDENT -> createModuleConfig [2513:49]
29360 | | |--ELIST -> ELIST [2513:84]
29361 | | | `--EXPR -> EXPR [2513:84]
29362 | | | `--DOT -> . [2513:84]
29363 | | | |--IDENT -> IndentationCheck [2513:68]
29364 | | | `--LITERAL_CLASS -> class [2513:85]
29365 | | `--RPAREN -> ) [2513:90]
29366 | |--SEMI -> ; [2513:91]
29367 | |--EXPR -> EXPR [2514:32]
29368 | | `--METHOD_CALL -> ( [2514:32]
29369 | | |--DOT -> . [2514:19]
29370 | | | |--IDENT -> checkConfig [2514:8]
29371 | | | `--IDENT -> addAttribute [2514:20]
29372 | | |--ELIST -> ELIST [2514:33]
29373 | | | |--EXPR -> EXPR [2514:33]
29374 | | | | `--STRING_LITERAL -> "tabWidth" [2514:33]
29375 | | | |--COMMA -> , [2514:43]
29376 | | | `--EXPR -> EXPR [2514:45]
29377 | | | `--STRING_LITERAL -> "4" [2514:45]
29378 | | `--RPAREN -> ) [2514:48]
29379 | |--SEMI -> ; [2514:49]
29380 | |--EXPR -> EXPR [2515:32]
29381 | | `--METHOD_CALL -> ( [2515:32]
29382 | | |--DOT -> . [2515:19]
29383 | | | |--IDENT -> checkConfig [2515:8]
29384 | | | `--IDENT -> addAttribute [2515:20]
29385 | | |--ELIST -> ELIST [2515:33]
29386 | | | |--EXPR -> EXPR [2515:33]
29387 | | | | `--STRING_LITERAL -> "forceStrictCondition" [2515:33]
29388 | | | |--COMMA -> , [2515:55]
29389 | | | `--EXPR -> EXPR [2515:57]
29390 | | | `--STRING_LITERAL -> "true" [2515:57]
29391 | | `--RPAREN -> ) [2515:63]
29392 | |--SEMI -> ; [2515:64]
29393 | |--EXPR -> EXPR [2516:32]
29394 | | `--METHOD_CALL -> ( [2516:32]
29395 | | |--DOT -> . [2516:19]
29396 | | | |--IDENT -> checkConfig [2516:8]
29397 | | | `--IDENT -> addAttribute [2516:20]
29398 | | |--ELIST -> ELIST [2516:33]
29399 | | | |--EXPR -> EXPR [2516:33]
29400 | | | | `--STRING_LITERAL -> "braceAdjustment" [2516:33]
29401 | | | |--COMMA -> , [2516:50]
29402 | | | `--EXPR -> EXPR [2516:52]
29403 | | | `--STRING_LITERAL -> "0" [2516:52]
29404 | | `--RPAREN -> ) [2516:55]
29405 | |--SEMI -> ; [2516:56]
29406 | |--EXPR -> EXPR [2517:32]
29407 | | `--METHOD_CALL -> ( [2517:32]
29408 | | |--DOT -> . [2517:19]
29409 | | | |--IDENT -> checkConfig [2517:8]
29410 | | | `--IDENT -> addAttribute [2517:20]
29411 | | |--ELIST -> ELIST [2517:33]
29412 | | | |--EXPR -> EXPR [2517:33]
29413 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2517:33]
29414 | | | |--COMMA -> , [2517:58]
29415 | | | `--EXPR -> EXPR [2517:60]
29416 | | | `--STRING_LITERAL -> "4" [2517:60]
29417 | | `--RPAREN -> ) [2517:63]
29418 | |--SEMI -> ; [2517:64]
29419 | |--VARIABLE_DEF -> VARIABLE_DEF [2518:8]
29420 | | |--MODIFIERS -> MODIFIERS [2518:8]
29421 | | | `--FINAL -> final [2518:8]
29422 | | |--TYPE -> TYPE [2518:14]
29423 | | | `--IDENT -> String [2518:14]
29424 | | |--IDENT -> fileName [2518:21]
29425 | | `--ASSIGN -> = [2518:30]
29426 | | `--EXPR -> EXPR [2518:39]
29427 | | `--METHOD_CALL -> ( [2518:39]
29428 | | |--IDENT -> getPath [2518:32]
29429 | | |--ELIST -> ELIST [2518:40]
29430 | | | `--EXPR -> EXPR [2518:40]
29431 | | | `--STRING_LITERAL -> "InputIndentationTryWithResourcesStrict.java" [2518:40]
29432 | | `--RPAREN -> ) [2518:85]
29433 | |--SEMI -> ; [2518:86]
29434 | |--VARIABLE_DEF -> VARIABLE_DEF [2519:8]
29435 | | |--MODIFIERS -> MODIFIERS [2519:8]
29436 | | | `--FINAL -> final [2519:8]
29437 | | |--TYPE -> TYPE [2519:20]
29438 | | | `--ARRAY_DECLARATOR -> [ [2519:20]
29439 | | | |--IDENT -> String [2519:14]
29440 | | | `--RBRACK -> ] [2519:21]
29441 | | |--IDENT -> expected [2519:23]
29442 | | `--ASSIGN -> = [2519:32]
29443 | | `--ARRAY_INIT -> { [2519:34]
29444 | | |--EXPR -> EXPR [2520:21]
29445 | | | `--PLUS -> + [2520:21]
29446 | | | |--STRING_LITERAL -> "26:1: " [2520:12]
29447 | | | `--METHOD_CALL -> ( [2520:38]
29448 | | | |--IDENT -> getCheckMessage [2520:23]
29449 | | | |--ELIST -> ELIST [2520:39]
29450 | | | | |--EXPR -> EXPR [2520:39]
29451 | | | | | `--IDENT -> MSG_ERROR [2520:39]
29452 | | | | |--COMMA -> , [2520:48]
29453 | | | | |--EXPR -> EXPR [2520:50]
29454 | | | | | `--STRING_LITERAL -> "try resource" [2520:50]
29455 | | | | |--COMMA -> , [2520:64]
29456 | | | | |--EXPR -> EXPR [2520:66]
29457 | | | | | `--NUM_INT -> 0 [2520:66]
29458 | | | | |--COMMA -> , [2520:67]
29459 | | | | `--EXPR -> EXPR [2520:69]
29460 | | | | `--NUM_INT -> 12 [2520:69]
29461 | | | `--RPAREN -> ) [2520:71]
29462 | | |--COMMA -> , [2520:72]
29463 | | |--EXPR -> EXPR [2521:22]
29464 | | | `--PLUS -> + [2521:22]
29465 | | | |--STRING_LITERAL -> "28:14: " [2521:12]
29466 | | | `--METHOD_CALL -> ( [2521:39]
29467 | | | |--IDENT -> getCheckMessage [2521:24]
29468 | | | |--ELIST -> ELIST [2521:40]
29469 | | | | |--EXPR -> EXPR [2521:40]
29470 | | | | | `--IDENT -> MSG_ERROR_MULTI [2521:40]
29471 | | | | |--COMMA -> , [2521:55]
29472 | | | | |--EXPR -> EXPR [2521:57]
29473 | | | | | `--STRING_LITERAL -> "try rparen" [2521:57]
29474 | | | | |--COMMA -> , [2521:69]
29475 | | | | |--EXPR -> EXPR [2521:71]
29476 | | | | | `--NUM_INT -> 13 [2521:71]
29477 | | | | |--COMMA -> , [2521:73]
29478 | | | | `--EXPR -> EXPR [2521:75]
29479 | | | | `--STRING_LITERAL -> "8, 12" [2521:75]
29480 | | | `--RPAREN -> ) [2521:82]
29481 | | |--COMMA -> , [2521:83]
29482 | | |--EXPR -> EXPR [2522:21]
29483 | | | `--PLUS -> + [2522:21]
29484 | | | |--STRING_LITERAL -> "33:1: " [2522:12]
29485 | | | `--METHOD_CALL -> ( [2522:38]
29486 | | | |--IDENT -> getCheckMessage [2522:23]
29487 | | | |--ELIST -> ELIST [2522:39]
29488 | | | | |--EXPR -> EXPR [2522:39]
29489 | | | | | `--IDENT -> MSG_ERROR [2522:39]
29490 | | | | |--COMMA -> , [2522:48]
29491 | | | | |--EXPR -> EXPR [2522:50]
29492 | | | | | `--STRING_LITERAL -> "newBufferedWriter" [2522:50]
29493 | | | | |--COMMA -> , [2522:69]
29494 | | | | |--EXPR -> EXPR [2522:71]
29495 | | | | | `--NUM_INT -> 0 [2522:71]
29496 | | | | |--COMMA -> , [2522:72]
29497 | | | | `--EXPR -> EXPR [2522:74]
29498 | | | | `--NUM_INT -> 16 [2522:74]
29499 | | | `--RPAREN -> ) [2522:76]
29500 | | |--COMMA -> , [2522:77]
29501 | | |--EXPR -> EXPR [2523:21]
29502 | | | `--PLUS -> + [2523:21]
29503 | | | |--STRING_LITERAL -> "39:1: " [2523:12]
29504 | | | `--METHOD_CALL -> ( [2523:38]
29505 | | | |--IDENT -> getCheckMessage [2523:23]
29506 | | | |--ELIST -> ELIST [2523:39]
29507 | | | | |--EXPR -> EXPR [2523:39]
29508 | | | | | `--IDENT -> MSG_ERROR [2523:39]
29509 | | | | |--COMMA -> , [2523:48]
29510 | | | | |--EXPR -> EXPR [2523:50]
29511 | | | | | `--STRING_LITERAL -> "newBufferedWriter" [2523:50]
29512 | | | | |--COMMA -> , [2523:69]
29513 | | | | |--EXPR -> EXPR [2523:71]
29514 | | | | | `--NUM_INT -> 0 [2523:71]
29515 | | | | |--COMMA -> , [2523:72]
29516 | | | | `--EXPR -> EXPR [2523:74]
29517 | | | | `--NUM_INT -> 12 [2523:74]
29518 | | | `--RPAREN -> ) [2523:76]
29519 | | |--COMMA -> , [2523:77]
29520 | | |--EXPR -> EXPR [2524:22]
29521 | | | `--PLUS -> + [2524:22]
29522 | | | |--STRING_LITERAL -> "59:21: " [2524:12]
29523 | | | `--METHOD_CALL -> ( [2524:39]
29524 | | | |--IDENT -> getCheckMessage [2524:24]
29525 | | | |--ELIST -> ELIST [2524:40]
29526 | | | | |--EXPR -> EXPR [2524:40]
29527 | | | | | `--IDENT -> MSG_ERROR [2524:40]
29528 | | | | |--COMMA -> , [2524:49]
29529 | | | | |--EXPR -> EXPR [2524:51]
29530 | | | | | `--STRING_LITERAL -> "try resource" [2524:51]
29531 | | | | |--COMMA -> , [2524:65]
29532 | | | | |--EXPR -> EXPR [2524:67]
29533 | | | | | `--NUM_INT -> 20 [2524:67]
29534 | | | | |--COMMA -> , [2524:69]
29535 | | | | `--EXPR -> EXPR [2524:71]
29536 | | | | `--NUM_INT -> 16 [2524:71]
29537 | | | `--RPAREN -> ) [2524:73]
29538 | | |--COMMA -> , [2524:74]
29539 | | |--EXPR -> EXPR [2525:22]
29540 | | | `--PLUS -> + [2525:22]
29541 | | | |--STRING_LITERAL -> "84:20: " [2525:12]
29542 | | | `--METHOD_CALL -> ( [2525:39]
29543 | | | |--IDENT -> getCheckMessage [2525:24]
29544 | | | |--ELIST -> ELIST [2525:40]
29545 | | | | |--EXPR -> EXPR [2525:40]
29546 | | | | | `--IDENT -> MSG_ERROR [2525:40]
29547 | | | | |--COMMA -> , [2525:49]
29548 | | | | |--EXPR -> EXPR [2525:51]
29549 | | | | | `--STRING_LITERAL -> "writ" [2525:51]
29550 | | | | |--COMMA -> , [2525:57]
29551 | | | | |--EXPR -> EXPR [2525:59]
29552 | | | | | `--NUM_INT -> 19 [2525:59]
29553 | | | | |--COMMA -> , [2525:61]
29554 | | | | `--EXPR -> EXPR [2525:63]
29555 | | | | `--NUM_INT -> 12 [2525:63]
29556 | | | `--RPAREN -> ) [2525:65]
29557 | | |--COMMA -> , [2525:66]
29558 | | |--EXPR -> EXPR [2526:22]
29559 | | | `--PLUS -> + [2526:22]
29560 | | | |--STRING_LITERAL -> "91:20: " [2526:12]
29561 | | | `--METHOD_CALL -> ( [2526:39]
29562 | | | |--IDENT -> getCheckMessage [2526:24]
29563 | | | |--ELIST -> ELIST [2526:40]
29564 | | | | |--EXPR -> EXPR [2526:40]
29565 | | | | | `--IDENT -> MSG_ERROR [2526:40]
29566 | | | | |--COMMA -> , [2526:49]
29567 | | | | |--EXPR -> EXPR [2526:51]
29568 | | | | | `--STRING_LITERAL -> "writ" [2526:51]
29569 | | | | |--COMMA -> , [2526:57]
29570 | | | | |--EXPR -> EXPR [2526:59]
29571 | | | | | `--NUM_INT -> 19 [2526:59]
29572 | | | | |--COMMA -> , [2526:61]
29573 | | | | `--EXPR -> EXPR [2526:63]
29574 | | | | `--NUM_INT -> 16 [2526:63]
29575 | | | `--RPAREN -> ) [2526:65]
29576 | | |--COMMA -> , [2526:66]
29577 | | |--EXPR -> EXPR [2527:22]
29578 | | | `--PLUS -> + [2527:22]
29579 | | | |--STRING_LITERAL -> "98:22: " [2527:12]
29580 | | | `--METHOD_CALL -> ( [2527:39]
29581 | | | |--IDENT -> getCheckMessage [2527:24]
29582 | | | |--ELIST -> ELIST [2527:40]
29583 | | | | |--EXPR -> EXPR [2527:40]
29584 | | | | | `--IDENT -> MSG_ERROR [2527:40]
29585 | | | | |--COMMA -> , [2527:49]
29586 | | | | |--EXPR -> EXPR [2527:51]
29587 | | | | | `--STRING_LITERAL -> "writ" [2527:51]
29588 | | | | |--COMMA -> , [2527:57]
29589 | | | | |--EXPR -> EXPR [2527:59]
29590 | | | | | `--NUM_INT -> 21 [2527:59]
29591 | | | | |--COMMA -> , [2527:61]
29592 | | | | `--EXPR -> EXPR [2527:63]
29593 | | | | `--NUM_INT -> 16 [2527:63]
29594 | | | `--RPAREN -> ) [2527:65]
29595 | | |--COMMA -> , [2527:66]
29596 | | |--EXPR -> EXPR [2528:23]
29597 | | | `--PLUS -> + [2528:23]
29598 | | | |--STRING_LITERAL -> "113:18: " [2528:12]
29599 | | | `--METHOD_CALL -> ( [2528:40]
29600 | | | |--IDENT -> getCheckMessage [2528:25]
29601 | | | |--ELIST -> ELIST [2528:41]
29602 | | | | |--EXPR -> EXPR [2528:41]
29603 | | | | | `--IDENT -> MSG_ERROR [2528:41]
29604 | | | | |--COMMA -> , [2528:50]
29605 | | | | |--EXPR -> EXPR [2528:52]
29606 | | | | | `--STRING_LITERAL -> "zipFileName" [2528:52]
29607 | | | | |--COMMA -> , [2528:65]
29608 | | | | |--EXPR -> EXPR [2528:67]
29609 | | | | | `--NUM_INT -> 17 [2528:67]
29610 | | | | |--COMMA -> , [2528:69]
29611 | | | | `--EXPR -> EXPR [2528:71]
29612 | | | | `--NUM_INT -> 16 [2528:71]
29613 | | | `--RPAREN -> ) [2528:73]
29614 | | |--COMMA -> , [2528:74]
29615 | | |--EXPR -> EXPR [2529:23]
29616 | | | `--PLUS -> + [2529:23]
29617 | | | |--STRING_LITERAL -> "120:16: " [2529:12]
29618 | | | `--METHOD_CALL -> ( [2529:40]
29619 | | | |--IDENT -> getCheckMessage [2529:25]
29620 | | | |--ELIST -> ELIST [2529:41]
29621 | | | | |--EXPR -> EXPR [2529:41]
29622 | | | | | `--IDENT -> MSG_ERROR [2529:41]
29623 | | | | |--COMMA -> , [2529:50]
29624 | | | | |--EXPR -> EXPR [2529:52]
29625 | | | | | `--STRING_LITERAL -> "zipFileName" [2529:52]
29626 | | | | |--COMMA -> , [2529:65]
29627 | | | | |--EXPR -> EXPR [2529:67]
29628 | | | | | `--NUM_INT -> 15 [2529:67]
29629 | | | | |--COMMA -> , [2529:69]
29630 | | | | `--EXPR -> EXPR [2529:71]
29631 | | | | `--NUM_INT -> 16 [2529:71]
29632 | | | `--RPAREN -> ) [2529:73]
29633 | | |--COMMA -> , [2529:74]
29634 | | |--EXPR -> EXPR [2530:22]
29635 | | | `--PLUS -> + [2530:22]
29636 | | | |--STRING_LITERAL -> "130:8: " [2530:12]
29637 | | | `--METHOD_CALL -> ( [2530:39]
29638 | | | |--IDENT -> getCheckMessage [2530:24]
29639 | | | |--ELIST -> ELIST [2530:40]
29640 | | | | |--EXPR -> EXPR [2530:40]
29641 | | | | | `--IDENT -> MSG_ERROR [2530:40]
29642 | | | | |--COMMA -> , [2530:49]
29643 | | | | |--EXPR -> EXPR [2530:51]
29644 | | | | | `--STRING_LITERAL -> "try" [2530:51]
29645 | | | | |--COMMA -> , [2530:56]
29646 | | | | |--EXPR -> EXPR [2530:58]
29647 | | | | | `--NUM_INT -> 7 [2530:58]
29648 | | | | |--COMMA -> , [2530:59]
29649 | | | | `--EXPR -> EXPR [2530:61]
29650 | | | | `--NUM_INT -> 8 [2530:61]
29651 | | | `--RPAREN -> ) [2530:62]
29652 | | |--COMMA -> , [2530:63]
29653 | | |--EXPR -> EXPR [2531:23]
29654 | | | `--PLUS -> + [2531:23]
29655 | | | |--STRING_LITERAL -> "135:16: " [2531:12]
29656 | | | `--METHOD_CALL -> ( [2531:40]
29657 | | | |--IDENT -> getCheckMessage [2531:25]
29658 | | | |--ELIST -> ELIST [2531:41]
29659 | | | | |--EXPR -> EXPR [2531:41]
29660 | | | | | `--IDENT -> MSG_CHILD_ERROR [2531:41]
29661 | | | | |--COMMA -> , [2531:56]
29662 | | | | |--EXPR -> EXPR [2531:58]
29663 | | | | | `--STRING_LITERAL -> "try" [2531:58]
29664 | | | | |--COMMA -> , [2531:63]
29665 | | | | |--EXPR -> EXPR [2531:65]
29666 | | | | | `--NUM_INT -> 15 [2531:65]
29667 | | | | |--COMMA -> , [2531:67]
29668 | | | | `--EXPR -> EXPR [2531:69]
29669 | | | | `--NUM_INT -> 12 [2531:69]
29670 | | | `--RPAREN -> ) [2531:71]
29671 | | |--COMMA -> , [2531:72]
29672 | | |--EXPR -> EXPR [2532:23]
29673 | | | `--PLUS -> + [2532:23]
29674 | | | |--STRING_LITERAL -> "141:12: " [2532:12]
29675 | | | `--METHOD_CALL -> ( [2532:40]
29676 | | | |--IDENT -> getCheckMessage [2532:25]
29677 | | | |--ELIST -> ELIST [2532:41]
29678 | | | | |--EXPR -> EXPR [2532:41]
29679 | | | | | `--IDENT -> MSG_ERROR [2532:41]
29680 | | | | |--COMMA -> , [2532:50]
29681 | | | | |--EXPR -> EXPR [2532:52]
29682 | | | | | `--STRING_LITERAL -> "try resource" [2532:52]
29683 | | | | |--COMMA -> , [2532:66]
29684 | | | | |--EXPR -> EXPR [2532:68]
29685 | | | | | `--NUM_INT -> 11 [2532:68]
29686 | | | | |--COMMA -> , [2532:70]
29687 | | | | `--EXPR -> EXPR [2532:72]
29688 | | | | `--NUM_INT -> 12 [2532:72]
29689 | | | `--RPAREN -> ) [2532:74]
29690 | | |--COMMA -> , [2532:75]
29691 | | |--EXPR -> EXPR [2533:23]
29692 | | | `--PLUS -> + [2533:23]
29693 | | | |--STRING_LITERAL -> "142:10: " [2533:12]
29694 | | | `--METHOD_CALL -> ( [2533:40]
29695 | | | |--IDENT -> getCheckMessage [2533:25]
29696 | | | |--ELIST -> ELIST [2533:41]
29697 | | | | |--EXPR -> EXPR [2533:41]
29698 | | | | | `--IDENT -> MSG_CHILD_ERROR [2533:41]
29699 | | | | |--COMMA -> , [2533:56]
29700 | | | | |--EXPR -> EXPR [2533:58]
29701 | | | | | `--STRING_LITERAL -> "try" [2533:58]
29702 | | | | |--COMMA -> , [2533:63]
29703 | | | | |--EXPR -> EXPR [2533:65]
29704 | | | | | `--NUM_INT -> 9 [2533:65]
29705 | | | | |--COMMA -> , [2533:66]
29706 | | | | `--EXPR -> EXPR [2533:68]
29707 | | | | `--NUM_INT -> 12 [2533:68]
29708 | | | `--RPAREN -> ) [2533:70]
29709 | | |--COMMA -> , [2533:71]
29710 | | |--EXPR -> EXPR [2534:23]
29711 | | | `--PLUS -> + [2534:23]
29712 | | | |--STRING_LITERAL -> "146:12: " [2534:12]
29713 | | | `--METHOD_CALL -> ( [2534:40]
29714 | | | |--IDENT -> getCheckMessage [2534:25]
29715 | | | |--ELIST -> ELIST [2534:41]
29716 | | | | |--EXPR -> EXPR [2534:41]
29717 | | | | | `--IDENT -> MSG_ERROR [2534:41]
29718 | | | | |--COMMA -> , [2534:50]
29719 | | | | |--EXPR -> EXPR [2534:52]
29720 | | | | | `--STRING_LITERAL -> "try resource" [2534:52]
29721 | | | | |--COMMA -> , [2534:66]
29722 | | | | |--EXPR -> EXPR [2534:68]
29723 | | | | | `--NUM_INT -> 11 [2534:68]
29724 | | | | |--COMMA -> , [2534:70]
29725 | | | | `--EXPR -> EXPR [2534:72]
29726 | | | | `--NUM_INT -> 12 [2534:72]
29727 | | | `--RPAREN -> ) [2534:74]
29728 | | |--COMMA -> , [2534:75]
29729 | | |--EXPR -> EXPR [2535:23]
29730 | | | `--PLUS -> + [2535:23]
29731 | | | |--STRING_LITERAL -> "147:12: " [2535:12]
29732 | | | `--METHOD_CALL -> ( [2535:40]
29733 | | | |--IDENT -> getCheckMessage [2535:25]
29734 | | | |--ELIST -> ELIST [2535:41]
29735 | | | | |--EXPR -> EXPR [2535:41]
29736 | | | | | `--IDENT -> MSG_ERROR [2535:41]
29737 | | | | |--COMMA -> , [2535:50]
29738 | | | | |--EXPR -> EXPR [2535:52]
29739 | | | | | `--STRING_LITERAL -> "newBufferedWriter" [2535:52]
29740 | | | | |--COMMA -> , [2535:71]
29741 | | | | |--EXPR -> EXPR [2535:73]
29742 | | | | | `--NUM_INT -> 11 [2535:73]
29743 | | | | |--COMMA -> , [2535:75]
29744 | | | | `--EXPR -> EXPR [2535:77]
29745 | | | | `--NUM_INT -> 16 [2535:77]
29746 | | | `--RPAREN -> ) [2535:79]
29747 | | |--COMMA -> , [2535:80]
29748 | | |--EXPR -> EXPR [2536:23]
29749 | | | `--PLUS -> + [2536:23]
29750 | | | |--STRING_LITERAL -> "148:14: " [2536:12]
29751 | | | `--METHOD_CALL -> ( [2536:40]
29752 | | | |--IDENT -> getCheckMessage [2536:25]
29753 | | | |--ELIST -> ELIST [2536:41]
29754 | | | | |--EXPR -> EXPR [2536:41]
29755 | | | | | `--IDENT -> MSG_CHILD_ERROR [2536:41]
29756 | | | | |--COMMA -> , [2536:56]
29757 | | | | |--EXPR -> EXPR [2536:58]
29758 | | | | | `--STRING_LITERAL -> "try" [2536:58]
29759 | | | | |--COMMA -> , [2536:63]
29760 | | | | |--EXPR -> EXPR [2536:65]
29761 | | | | | `--NUM_INT -> 13 [2536:65]
29762 | | | | |--COMMA -> , [2536:67]
29763 | | | | `--EXPR -> EXPR [2536:69]
29764 | | | | `--NUM_INT -> 12 [2536:69]
29765 | | | `--RPAREN -> ) [2536:71]
29766 | | |--COMMA -> , [2536:72]
29767 | | |--EXPR -> EXPR [2537:22]
29768 | | | `--PLUS -> + [2537:22]
29769 | | | |--STRING_LITERAL -> "150:8: " [2537:12]
29770 | | | `--METHOD_CALL -> ( [2537:39]
29771 | | | |--IDENT -> getCheckMessage [2537:24]
29772 | | | |--ELIST -> ELIST [2537:40]
29773 | | | | |--EXPR -> EXPR [2537:40]
29774 | | | | | `--IDENT -> MSG_ERROR [2537:40]
29775 | | | | |--COMMA -> , [2537:49]
29776 | | | | |--EXPR -> EXPR [2537:51]
29777 | | | | | `--STRING_LITERAL -> "try" [2537:51]
29778 | | | | |--COMMA -> , [2537:56]
29779 | | | | |--EXPR -> EXPR [2537:58]
29780 | | | | | `--NUM_INT -> 7 [2537:58]
29781 | | | | |--COMMA -> , [2537:59]
29782 | | | | `--EXPR -> EXPR [2537:61]
29783 | | | | `--NUM_INT -> 8 [2537:61]
29784 | | | `--RPAREN -> ) [2537:62]
29785 | | |--COMMA -> , [2537:63]
29786 | | |--EXPR -> EXPR [2538:22]
29787 | | | `--PLUS -> + [2538:22]
29788 | | | |--STRING_LITERAL -> "151:8: " [2538:12]
29789 | | | `--METHOD_CALL -> ( [2538:39]
29790 | | | |--IDENT -> getCheckMessage [2538:24]
29791 | | | |--ELIST -> ELIST [2538:40]
29792 | | | | |--EXPR -> EXPR [2538:40]
29793 | | | | | `--IDENT -> MSG_ERROR_MULTI [2538:40]
29794 | | | | |--COMMA -> , [2538:55]
29795 | | | | |--EXPR -> EXPR [2538:57]
29796 | | | | | `--STRING_LITERAL -> "try rparen" [2538:57]
29797 | | | | |--COMMA -> , [2538:69]
29798 | | | | |--EXPR -> EXPR [2538:71]
29799 | | | | | `--NUM_INT -> 7 [2538:71]
29800 | | | | |--COMMA -> , [2538:72]
29801 | | | | `--EXPR -> EXPR [2538:74]
29802 | | | | `--STRING_LITERAL -> "8, 12" [2538:74]
29803 | | | `--RPAREN -> ) [2538:81]
29804 | | |--COMMA -> , [2538:82]
29805 | | |--EXPR -> EXPR [2539:23]
29806 | | | `--PLUS -> + [2539:23]
29807 | | | |--STRING_LITERAL -> "155:10: " [2539:12]
29808 | | | `--METHOD_CALL -> ( [2539:40]
29809 | | | |--IDENT -> getCheckMessage [2539:25]
29810 | | | |--ELIST -> ELIST [2539:41]
29811 | | | | |--EXPR -> EXPR [2539:41]
29812 | | | | | `--IDENT -> MSG_ERROR [2539:41]
29813 | | | | |--COMMA -> , [2539:50]
29814 | | | | |--EXPR -> EXPR [2539:52]
29815 | | | | | `--STRING_LITERAL -> "try" [2539:52]
29816 | | | | |--COMMA -> , [2539:57]
29817 | | | | |--EXPR -> EXPR [2539:59]
29818 | | | | | `--NUM_INT -> 9 [2539:59]
29819 | | | | |--COMMA -> , [2539:60]
29820 | | | | `--EXPR -> EXPR [2539:62]
29821 | | | | `--NUM_INT -> 8 [2539:62]
29822 | | | `--RPAREN -> ) [2539:63]
29823 | | |--COMMA -> , [2539:64]
29824 | | |--EXPR -> EXPR [2540:23]
29825 | | | `--PLUS -> + [2540:23]
29826 | | | |--STRING_LITERAL -> "161:14: " [2540:12]
29827 | | | `--METHOD_CALL -> ( [2540:40]
29828 | | | |--IDENT -> getCheckMessage [2540:25]
29829 | | | |--ELIST -> ELIST [2540:41]
29830 | | | | |--EXPR -> EXPR [2540:41]
29831 | | | | | `--IDENT -> MSG_ERROR [2540:41]
29832 | | | | |--COMMA -> , [2540:50]
29833 | | | | |--EXPR -> EXPR [2540:52]
29834 | | | | | `--STRING_LITERAL -> "." [2540:52]
29835 | | | | |--COMMA -> , [2540:55]
29836 | | | | |--EXPR -> EXPR [2540:57]
29837 | | | | | `--NUM_INT -> 13 [2540:57]
29838 | | | | |--COMMA -> , [2540:59]
29839 | | | | `--EXPR -> EXPR [2540:61]
29840 | | | | `--NUM_INT -> 12 [2540:61]
29841 | | | `--RPAREN -> ) [2540:63]
29842 | | |--COMMA -> , [2540:64]
29843 | | |--EXPR -> EXPR [2541:23]
29844 | | | `--PLUS -> + [2541:23]
29845 | | | |--STRING_LITERAL -> "167:12: " [2541:12]
29846 | | | `--METHOD_CALL -> ( [2541:40]
29847 | | | |--IDENT -> getCheckMessage [2541:25]
29848 | | | |--ELIST -> ELIST [2541:41]
29849 | | | | |--EXPR -> EXPR [2541:41]
29850 | | | | | `--IDENT -> MSG_ERROR [2541:41]
29851 | | | | |--COMMA -> , [2541:50]
29852 | | | | |--EXPR -> EXPR [2541:52]
29853 | | | | | `--STRING_LITERAL -> "." [2541:52]
29854 | | | | |--COMMA -> , [2541:55]
29855 | | | | |--EXPR -> EXPR [2541:57]
29856 | | | | | `--NUM_INT -> 11 [2541:57]
29857 | | | | |--COMMA -> , [2541:59]
29858 | | | | `--EXPR -> EXPR [2541:61]
29859 | | | | `--NUM_INT -> 12 [2541:61]
29860 | | | `--RPAREN -> ) [2541:63]
29861 | | |--COMMA -> , [2541:64]
29862 | | `--RCURLY -> } [2542:8]
29863 | |--SEMI -> ; [2542:9]
29864 | |--EXPR -> EXPR [2543:19]
29865 | | `--METHOD_CALL -> ( [2543:19]
29866 | | |--IDENT -> verifyWarns [2543:8]
29867 | | |--ELIST -> ELIST [2543:20]
29868 | | | |--EXPR -> EXPR [2543:20]
29869 | | | | `--IDENT -> checkConfig [2543:20]
29870 | | | |--COMMA -> , [2543:31]
29871 | | | |--EXPR -> EXPR [2543:33]
29872 | | | | `--IDENT -> fileName [2543:33]
29873 | | | |--COMMA -> , [2543:41]
29874 | | | `--EXPR -> EXPR [2543:43]
29875 | | | `--IDENT -> expected [2543:43]
29876 | | `--RPAREN -> ) [2543:51]
29877 | |--SEMI -> ; [2543:52]
29878 | `--RCURLY -> } [2544:4]
29879 |--METHOD_DEF -> METHOD_DEF [2546:4]
29880 | |--MODIFIERS -> MODIFIERS [2546:4]
29881 | | |--ANNOTATION -> ANNOTATION [2546:4]
29882 | | | |--AT -> @ [2546:4]
29883 | | | `--IDENT -> Test [2546:5]
29884 | | `--LITERAL_PUBLIC -> public [2547:4]
29885 | |--TYPE -> TYPE [2547:11]
29886 | | `--LITERAL_VOID -> void [2547:11]
29887 | |--IDENT -> testTryResourcesNotStrict [2547:16]
29888 | |--LPAREN -> ( [2547:41]
29889 | |--PARAMETERS -> PARAMETERS [2547:42]
29890 | |--RPAREN -> ) [2547:42]
29891 | |--LITERAL_THROWS -> throws [2547:44]
29892 | | `--IDENT -> Exception [2547:51]
29893 | `--SLIST -> { [2547:61]
29894 | |--VARIABLE_DEF -> VARIABLE_DEF [2548:8]
29895 | | |--MODIFIERS -> MODIFIERS [2548:8]
29896 | | | `--FINAL -> final [2548:8]
29897 | | |--TYPE -> TYPE [2548:14]
29898 | | | `--IDENT -> DefaultConfiguration [2548:14]
29899 | | |--IDENT -> checkConfig [2548:35]
29900 | | `--ASSIGN -> = [2548:47]
29901 | | `--EXPR -> EXPR [2548:67]
29902 | | `--METHOD_CALL -> ( [2548:67]
29903 | | |--IDENT -> createModuleConfig [2548:49]
29904 | | |--ELIST -> ELIST [2548:84]
29905 | | | `--EXPR -> EXPR [2548:84]
29906 | | | `--DOT -> . [2548:84]
29907 | | | |--IDENT -> IndentationCheck [2548:68]
29908 | | | `--LITERAL_CLASS -> class [2548:85]
29909 | | `--RPAREN -> ) [2548:90]
29910 | |--SEMI -> ; [2548:91]
29911 | |--EXPR -> EXPR [2549:32]
29912 | | `--METHOD_CALL -> ( [2549:32]
29913 | | |--DOT -> . [2549:19]
29914 | | | |--IDENT -> checkConfig [2549:8]
29915 | | | `--IDENT -> addAttribute [2549:20]
29916 | | |--ELIST -> ELIST [2549:33]
29917 | | | |--EXPR -> EXPR [2549:33]
29918 | | | | `--STRING_LITERAL -> "tabWidth" [2549:33]
29919 | | | |--COMMA -> , [2549:43]
29920 | | | `--EXPR -> EXPR [2549:45]
29921 | | | `--STRING_LITERAL -> "4" [2549:45]
29922 | | `--RPAREN -> ) [2549:48]
29923 | |--SEMI -> ; [2549:49]
29924 | |--EXPR -> EXPR [2550:32]
29925 | | `--METHOD_CALL -> ( [2550:32]
29926 | | |--DOT -> . [2550:19]
29927 | | | |--IDENT -> checkConfig [2550:8]
29928 | | | `--IDENT -> addAttribute [2550:20]
29929 | | |--ELIST -> ELIST [2550:33]
29930 | | | |--EXPR -> EXPR [2550:33]
29931 | | | | `--STRING_LITERAL -> "braceAdjustment" [2550:33]
29932 | | | |--COMMA -> , [2550:50]
29933 | | | `--EXPR -> EXPR [2550:52]
29934 | | | `--STRING_LITERAL -> "0" [2550:52]
29935 | | `--RPAREN -> ) [2550:55]
29936 | |--SEMI -> ; [2550:56]
29937 | |--EXPR -> EXPR [2551:32]
29938 | | `--METHOD_CALL -> ( [2551:32]
29939 | | |--DOT -> . [2551:19]
29940 | | | |--IDENT -> checkConfig [2551:8]
29941 | | | `--IDENT -> addAttribute [2551:20]
29942 | | |--ELIST -> ELIST [2551:33]
29943 | | | |--EXPR -> EXPR [2551:33]
29944 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2551:33]
29945 | | | |--COMMA -> , [2551:58]
29946 | | | `--EXPR -> EXPR [2551:60]
29947 | | | `--STRING_LITERAL -> "4" [2551:60]
29948 | | `--RPAREN -> ) [2551:63]
29949 | |--SEMI -> ; [2551:64]
29950 | |--VARIABLE_DEF -> VARIABLE_DEF [2552:8]
29951 | | |--MODIFIERS -> MODIFIERS [2552:8]
29952 | | | `--FINAL -> final [2552:8]
29953 | | |--TYPE -> TYPE [2552:14]
29954 | | | `--IDENT -> String [2552:14]
29955 | | |--IDENT -> fileName [2552:21]
29956 | | `--ASSIGN -> = [2552:30]
29957 | | `--EXPR -> EXPR [2552:39]
29958 | | `--METHOD_CALL -> ( [2552:39]
29959 | | |--IDENT -> getPath [2552:32]
29960 | | |--ELIST -> ELIST [2552:40]
29961 | | | `--EXPR -> EXPR [2552:40]
29962 | | | `--STRING_LITERAL -> "InputIndentationTryResourcesNotStrict.java" [2552:40]
29963 | | `--RPAREN -> ) [2552:84]
29964 | |--SEMI -> ; [2552:85]
29965 | |--VARIABLE_DEF -> VARIABLE_DEF [2553:8]
29966 | | |--MODIFIERS -> MODIFIERS [2553:8]
29967 | | | `--FINAL -> final [2553:8]
29968 | | |--TYPE -> TYPE [2553:20]
29969 | | | `--ARRAY_DECLARATOR -> [ [2553:20]
29970 | | | |--IDENT -> String [2553:14]
29971 | | | `--RBRACK -> ] [2553:21]
29972 | | |--IDENT -> expected [2553:23]
29973 | | `--ASSIGN -> = [2553:32]
29974 | | `--ARRAY_INIT -> { [2553:34]
29975 | | |--EXPR -> EXPR [2554:21]
29976 | | | `--PLUS -> + [2554:21]
29977 | | | |--STRING_LITERAL -> "27:1: " [2554:12]
29978 | | | `--METHOD_CALL -> ( [2554:38]
29979 | | | |--IDENT -> getCheckMessage [2554:23]
29980 | | | |--ELIST -> ELIST [2554:39]
29981 | | | | |--EXPR -> EXPR [2554:39]
29982 | | | | | `--IDENT -> MSG_ERROR [2554:39]
29983 | | | | |--COMMA -> , [2554:48]
29984 | | | | |--EXPR -> EXPR [2554:50]
29985 | | | | | `--STRING_LITERAL -> "try resource" [2554:50]
29986 | | | | |--COMMA -> , [2554:64]
29987 | | | | |--EXPR -> EXPR [2554:66]
29988 | | | | | `--NUM_INT -> 0 [2554:66]
29989 | | | | |--COMMA -> , [2554:67]
29990 | | | | `--EXPR -> EXPR [2554:69]
29991 | | | | `--NUM_INT -> 12 [2554:69]
29992 | | | `--RPAREN -> ) [2554:71]
29993 | | |--COMMA -> , [2554:72]
29994 | | |--EXPR -> EXPR [2555:21]
29995 | | | `--PLUS -> + [2555:21]
29996 | | | |--STRING_LITERAL -> "33:1: " [2555:12]
29997 | | | `--METHOD_CALL -> ( [2555:38]
29998 | | | |--IDENT -> getCheckMessage [2555:23]
29999 | | | |--ELIST -> ELIST [2555:39]
30000 | | | | |--EXPR -> EXPR [2555:39]
30001 | | | | | `--IDENT -> MSG_ERROR [2555:39]
30002 | | | | |--COMMA -> , [2555:48]
30003 | | | | |--EXPR -> EXPR [2555:50]
30004 | | | | | `--STRING_LITERAL -> "newBufferedWriter" [2555:50]
30005 | | | | |--COMMA -> , [2555:69]
30006 | | | | |--EXPR -> EXPR [2555:71]
30007 | | | | | `--NUM_INT -> 0 [2555:71]
30008 | | | | |--COMMA -> , [2555:72]
30009 | | | | `--EXPR -> EXPR [2555:74]
30010 | | | | `--NUM_INT -> 16 [2555:74]
30011 | | | `--RPAREN -> ) [2555:76]
30012 | | |--COMMA -> , [2555:77]
30013 | | |--EXPR -> EXPR [2556:21]
30014 | | | `--PLUS -> + [2556:21]
30015 | | | |--STRING_LITERAL -> "39:1: " [2556:12]
30016 | | | `--METHOD_CALL -> ( [2556:38]
30017 | | | |--IDENT -> getCheckMessage [2556:23]
30018 | | | |--ELIST -> ELIST [2556:39]
30019 | | | | |--EXPR -> EXPR [2556:39]
30020 | | | | | `--IDENT -> MSG_ERROR [2556:39]
30021 | | | | |--COMMA -> , [2556:48]
30022 | | | | |--EXPR -> EXPR [2556:50]
30023 | | | | | `--STRING_LITERAL -> "newBufferedWriter" [2556:50]
30024 | | | | |--COMMA -> , [2556:69]
30025 | | | | |--EXPR -> EXPR [2556:71]
30026 | | | | | `--NUM_INT -> 0 [2556:71]
30027 | | | | |--COMMA -> , [2556:72]
30028 | | | | `--EXPR -> EXPR [2556:74]
30029 | | | | `--NUM_INT -> 12 [2556:74]
30030 | | | `--RPAREN -> ) [2556:76]
30031 | | |--COMMA -> , [2556:77]
30032 | | |--EXPR -> EXPR [2557:23]
30033 | | | `--PLUS -> + [2557:23]
30034 | | | |--STRING_LITERAL -> "120:16: " [2557:12]
30035 | | | `--METHOD_CALL -> ( [2557:40]
30036 | | | |--IDENT -> getCheckMessage [2557:25]
30037 | | | |--ELIST -> ELIST [2557:41]
30038 | | | | |--EXPR -> EXPR [2557:41]
30039 | | | | | `--IDENT -> MSG_ERROR [2557:41]
30040 | | | | |--COMMA -> , [2557:50]
30041 | | | | |--EXPR -> EXPR [2557:52]
30042 | | | | | `--STRING_LITERAL -> "zipFileName" [2557:52]
30043 | | | | |--COMMA -> , [2557:65]
30044 | | | | |--EXPR -> EXPR [2557:67]
30045 | | | | | `--NUM_INT -> 15 [2557:67]
30046 | | | | |--COMMA -> , [2557:69]
30047 | | | | `--EXPR -> EXPR [2557:71]
30048 | | | | `--NUM_INT -> 16 [2557:71]
30049 | | | `--RPAREN -> ) [2557:73]
30050 | | |--COMMA -> , [2557:74]
30051 | | |--EXPR -> EXPR [2558:22]
30052 | | | `--PLUS -> + [2558:22]
30053 | | | |--STRING_LITERAL -> "130:8: " [2558:12]
30054 | | | `--METHOD_CALL -> ( [2558:39]
30055 | | | |--IDENT -> getCheckMessage [2558:24]
30056 | | | |--ELIST -> ELIST [2558:40]
30057 | | | | |--EXPR -> EXPR [2558:40]
30058 | | | | | `--IDENT -> MSG_ERROR [2558:40]
30059 | | | | |--COMMA -> , [2558:49]
30060 | | | | |--EXPR -> EXPR [2558:51]
30061 | | | | | `--STRING_LITERAL -> "try" [2558:51]
30062 | | | | |--COMMA -> , [2558:56]
30063 | | | | |--EXPR -> EXPR [2558:58]
30064 | | | | | `--NUM_INT -> 7 [2558:58]
30065 | | | | |--COMMA -> , [2558:59]
30066 | | | | `--EXPR -> EXPR [2558:61]
30067 | | | | `--NUM_INT -> 8 [2558:61]
30068 | | | `--RPAREN -> ) [2558:62]
30069 | | |--COMMA -> , [2558:63]
30070 | | |--EXPR -> EXPR [2559:23]
30071 | | | `--PLUS -> + [2559:23]
30072 | | | |--STRING_LITERAL -> "135:16: " [2559:12]
30073 | | | `--METHOD_CALL -> ( [2559:40]
30074 | | | |--IDENT -> getCheckMessage [2559:25]
30075 | | | |--ELIST -> ELIST [2559:41]
30076 | | | | |--EXPR -> EXPR [2559:41]
30077 | | | | | `--IDENT -> MSG_CHILD_ERROR [2559:41]
30078 | | | | |--COMMA -> , [2559:56]
30079 | | | | |--EXPR -> EXPR [2559:58]
30080 | | | | | `--STRING_LITERAL -> "try" [2559:58]
30081 | | | | |--COMMA -> , [2559:63]
30082 | | | | |--EXPR -> EXPR [2559:65]
30083 | | | | | `--NUM_INT -> 15 [2559:65]
30084 | | | | |--COMMA -> , [2559:67]
30085 | | | | `--EXPR -> EXPR [2559:69]
30086 | | | | `--NUM_INT -> 12 [2559:69]
30087 | | | `--RPAREN -> ) [2559:71]
30088 | | |--COMMA -> , [2559:72]
30089 | | |--EXPR -> EXPR [2560:23]
30090 | | | `--PLUS -> + [2560:23]
30091 | | | |--STRING_LITERAL -> "141:12: " [2560:12]
30092 | | | `--METHOD_CALL -> ( [2560:40]
30093 | | | |--IDENT -> getCheckMessage [2560:25]
30094 | | | |--ELIST -> ELIST [2560:41]
30095 | | | | |--EXPR -> EXPR [2560:41]
30096 | | | | | `--IDENT -> MSG_ERROR [2560:41]
30097 | | | | |--COMMA -> , [2560:50]
30098 | | | | |--EXPR -> EXPR [2560:52]
30099 | | | | | `--STRING_LITERAL -> "try resource" [2560:52]
30100 | | | | |--COMMA -> , [2560:66]
30101 | | | | |--EXPR -> EXPR [2560:68]
30102 | | | | | `--NUM_INT -> 11 [2560:68]
30103 | | | | |--COMMA -> , [2560:70]
30104 | | | | `--EXPR -> EXPR [2560:72]
30105 | | | | `--NUM_INT -> 12 [2560:72]
30106 | | | `--RPAREN -> ) [2560:74]
30107 | | |--COMMA -> , [2560:75]
30108 | | |--EXPR -> EXPR [2561:23]
30109 | | | `--PLUS -> + [2561:23]
30110 | | | |--STRING_LITERAL -> "142:10: " [2561:12]
30111 | | | `--METHOD_CALL -> ( [2561:40]
30112 | | | |--IDENT -> getCheckMessage [2561:25]
30113 | | | |--ELIST -> ELIST [2561:41]
30114 | | | | |--EXPR -> EXPR [2561:41]
30115 | | | | | `--IDENT -> MSG_CHILD_ERROR [2561:41]
30116 | | | | |--COMMA -> , [2561:56]
30117 | | | | |--EXPR -> EXPR [2561:58]
30118 | | | | | `--STRING_LITERAL -> "try" [2561:58]
30119 | | | | |--COMMA -> , [2561:63]
30120 | | | | |--EXPR -> EXPR [2561:65]
30121 | | | | | `--NUM_INT -> 9 [2561:65]
30122 | | | | |--COMMA -> , [2561:66]
30123 | | | | `--EXPR -> EXPR [2561:68]
30124 | | | | `--NUM_INT -> 12 [2561:68]
30125 | | | `--RPAREN -> ) [2561:70]
30126 | | |--COMMA -> , [2561:71]
30127 | | |--EXPR -> EXPR [2562:23]
30128 | | | `--PLUS -> + [2562:23]
30129 | | | |--STRING_LITERAL -> "146:12: " [2562:12]
30130 | | | `--METHOD_CALL -> ( [2562:40]
30131 | | | |--IDENT -> getCheckMessage [2562:25]
30132 | | | |--ELIST -> ELIST [2562:41]
30133 | | | | |--EXPR -> EXPR [2562:41]
30134 | | | | | `--IDENT -> MSG_ERROR [2562:41]
30135 | | | | |--COMMA -> , [2562:50]
30136 | | | | |--EXPR -> EXPR [2562:52]
30137 | | | | | `--STRING_LITERAL -> "try resource" [2562:52]
30138 | | | | |--COMMA -> , [2562:66]
30139 | | | | |--EXPR -> EXPR [2562:68]
30140 | | | | | `--NUM_INT -> 11 [2562:68]
30141 | | | | |--COMMA -> , [2562:70]
30142 | | | | `--EXPR -> EXPR [2562:72]
30143 | | | | `--NUM_INT -> 12 [2562:72]
30144 | | | `--RPAREN -> ) [2562:74]
30145 | | |--COMMA -> , [2562:75]
30146 | | |--EXPR -> EXPR [2563:23]
30147 | | | `--PLUS -> + [2563:23]
30148 | | | |--STRING_LITERAL -> "147:12: " [2563:12]
30149 | | | `--METHOD_CALL -> ( [2563:40]
30150 | | | |--IDENT -> getCheckMessage [2563:25]
30151 | | | |--ELIST -> ELIST [2563:41]
30152 | | | | |--EXPR -> EXPR [2563:41]
30153 | | | | | `--IDENT -> MSG_ERROR [2563:41]
30154 | | | | |--COMMA -> , [2563:50]
30155 | | | | |--EXPR -> EXPR [2563:52]
30156 | | | | | `--STRING_LITERAL -> "newBufferedWriter" [2563:52]
30157 | | | | |--COMMA -> , [2563:71]
30158 | | | | |--EXPR -> EXPR [2563:73]
30159 | | | | | `--NUM_INT -> 11 [2563:73]
30160 | | | | |--COMMA -> , [2563:75]
30161 | | | | `--EXPR -> EXPR [2563:77]
30162 | | | | `--NUM_INT -> 16 [2563:77]
30163 | | | `--RPAREN -> ) [2563:79]
30164 | | |--COMMA -> , [2563:80]
30165 | | |--EXPR -> EXPR [2564:23]
30166 | | | `--PLUS -> + [2564:23]
30167 | | | |--STRING_LITERAL -> "148:14: " [2564:12]
30168 | | | `--METHOD_CALL -> ( [2564:40]
30169 | | | |--IDENT -> getCheckMessage [2564:25]
30170 | | | |--ELIST -> ELIST [2564:41]
30171 | | | | |--EXPR -> EXPR [2564:41]
30172 | | | | | `--IDENT -> MSG_CHILD_ERROR [2564:41]
30173 | | | | |--COMMA -> , [2564:56]
30174 | | | | |--EXPR -> EXPR [2564:58]
30175 | | | | | `--STRING_LITERAL -> "try" [2564:58]
30176 | | | | |--COMMA -> , [2564:63]
30177 | | | | |--EXPR -> EXPR [2564:65]
30178 | | | | | `--NUM_INT -> 13 [2564:65]
30179 | | | | |--COMMA -> , [2564:67]
30180 | | | | `--EXPR -> EXPR [2564:69]
30181 | | | | `--NUM_INT -> 12 [2564:69]
30182 | | | `--RPAREN -> ) [2564:71]
30183 | | |--COMMA -> , [2564:72]
30184 | | |--EXPR -> EXPR [2565:22]
30185 | | | `--PLUS -> + [2565:22]
30186 | | | |--STRING_LITERAL -> "150:8: " [2565:12]
30187 | | | `--METHOD_CALL -> ( [2565:39]
30188 | | | |--IDENT -> getCheckMessage [2565:24]
30189 | | | |--ELIST -> ELIST [2565:40]
30190 | | | | |--EXPR -> EXPR [2565:40]
30191 | | | | | `--IDENT -> MSG_ERROR [2565:40]
30192 | | | | |--COMMA -> , [2565:49]
30193 | | | | |--EXPR -> EXPR [2565:51]
30194 | | | | | `--STRING_LITERAL -> "try" [2565:51]
30195 | | | | |--COMMA -> , [2565:56]
30196 | | | | |--EXPR -> EXPR [2565:58]
30197 | | | | | `--NUM_INT -> 7 [2565:58]
30198 | | | | |--COMMA -> , [2565:59]
30199 | | | | `--EXPR -> EXPR [2565:61]
30200 | | | | `--NUM_INT -> 8 [2565:61]
30201 | | | `--RPAREN -> ) [2565:62]
30202 | | |--COMMA -> , [2565:63]
30203 | | |--EXPR -> EXPR [2566:22]
30204 | | | `--PLUS -> + [2566:22]
30205 | | | |--STRING_LITERAL -> "151:8: " [2566:12]
30206 | | | `--METHOD_CALL -> ( [2566:39]
30207 | | | |--IDENT -> getCheckMessage [2566:24]
30208 | | | |--ELIST -> ELIST [2566:40]
30209 | | | | |--EXPR -> EXPR [2566:40]
30210 | | | | | `--IDENT -> MSG_ERROR_MULTI [2566:40]
30211 | | | | |--COMMA -> , [2566:55]
30212 | | | | |--EXPR -> EXPR [2566:57]
30213 | | | | | `--STRING_LITERAL -> "try rparen" [2566:57]
30214 | | | | |--COMMA -> , [2566:69]
30215 | | | | |--EXPR -> EXPR [2566:71]
30216 | | | | | `--NUM_INT -> 7 [2566:71]
30217 | | | | |--COMMA -> , [2566:72]
30218 | | | | `--EXPR -> EXPR [2566:74]
30219 | | | | `--STRING_LITERAL -> "8, 12" [2566:74]
30220 | | | `--RPAREN -> ) [2566:81]
30221 | | |--COMMA -> , [2566:82]
30222 | | |--EXPR -> EXPR [2567:22]
30223 | | | `--PLUS -> + [2567:22]
30224 | | | |--STRING_LITERAL -> "164:9: " [2567:12]
30225 | | | `--METHOD_CALL -> ( [2567:39]
30226 | | | |--IDENT -> getCheckMessage [2567:24]
30227 | | | |--ELIST -> ELIST [2567:40]
30228 | | | | |--EXPR -> EXPR [2567:40]
30229 | | | | | `--IDENT -> MSG_ERROR [2567:40]
30230 | | | | |--COMMA -> , [2567:49]
30231 | | | | |--EXPR -> EXPR [2567:51]
30232 | | | | | `--STRING_LITERAL -> "." [2567:51]
30233 | | | | |--COMMA -> , [2567:54]
30234 | | | | |--EXPR -> EXPR [2567:56]
30235 | | | | | `--NUM_INT -> 8 [2567:56]
30236 | | | | |--COMMA -> , [2567:57]
30237 | | | | `--EXPR -> EXPR [2567:59]
30238 | | | | `--NUM_INT -> 12 [2567:59]
30239 | | | `--RPAREN -> ) [2567:61]
30240 | | |--COMMA -> , [2567:62]
30241 | | |--EXPR -> EXPR [2568:23]
30242 | | | `--PLUS -> + [2568:23]
30243 | | | |--STRING_LITERAL -> "172:12: " [2568:12]
30244 | | | `--METHOD_CALL -> ( [2568:40]
30245 | | | |--IDENT -> getCheckMessage [2568:25]
30246 | | | |--ELIST -> ELIST [2568:41]
30247 | | | | |--EXPR -> EXPR [2568:41]
30248 | | | | | `--IDENT -> MSG_ERROR [2568:41]
30249 | | | | |--COMMA -> , [2568:50]
30250 | | | | |--EXPR -> EXPR [2568:52]
30251 | | | | | `--STRING_LITERAL -> "new" [2568:52]
30252 | | | | |--COMMA -> , [2568:57]
30253 | | | | |--EXPR -> EXPR [2568:59]
30254 | | | | | `--NUM_INT -> 11 [2568:59]
30255 | | | | |--COMMA -> , [2568:61]
30256 | | | | `--EXPR -> EXPR [2568:63]
30257 | | | | `--NUM_INT -> 12 [2568:63]
30258 | | | `--RPAREN -> ) [2568:65]
30259 | | |--COMMA -> , [2568:66]
30260 | | `--RCURLY -> } [2569:8]
30261 | |--SEMI -> ; [2569:9]
30262 | |--EXPR -> EXPR [2570:19]
30263 | | `--METHOD_CALL -> ( [2570:19]
30264 | | |--IDENT -> verifyWarns [2570:8]
30265 | | |--ELIST -> ELIST [2570:20]
30266 | | | |--EXPR -> EXPR [2570:20]
30267 | | | | `--IDENT -> checkConfig [2570:20]
30268 | | | |--COMMA -> , [2570:31]
30269 | | | |--EXPR -> EXPR [2570:33]
30270 | | | | `--IDENT -> fileName [2570:33]
30271 | | | |--COMMA -> , [2570:41]
30272 | | | `--EXPR -> EXPR [2570:43]
30273 | | | `--IDENT -> expected [2570:43]
30274 | | `--RPAREN -> ) [2570:51]
30275 | |--SEMI -> ; [2570:52]
30276 | `--RCURLY -> } [2571:4]
30277 |--METHOD_DEF -> METHOD_DEF [2585:4]
30278 | |--MODIFIERS -> MODIFIERS [2585:4]
30279 | | |--ANNOTATION -> ANNOTATION [2585:4]
30280 | | | |--BLOCK_COMMENT_BEGIN -> /* [2573:4]
30281 | | | | |--COMMENT_CONTENT -> *\n * Verifies that the arguments of {@link IndentationCheck#MSG_ERROR},\n * {@link IndentationCheck#MSG_CHILD_ERROR}, {@link IndentationCheck#MSG_CHILD_ERROR_MULTI},\n * {@link IndentationCheck#MSG_CHILD_ERROR_MULTI} are in appropriate order.\n *\n * <p>In other tests, the argument 0 and text before it are chopped off and only the rest of\n * messages are verified. Therefore, the argument 0 is required to be the first argument in\n * the messages above. If we update the messages in the future, it is required to keep the\n * arguments in appropriate order to ensure other tests will work.</p>\n *\n * @see IndentComment#getExpectedMessagePostfix(String)\n [2573:6]
30282 | | | | | `--JAVADOC -> JAVADOC [2573:7]
30283 | | | | | |--NEWLINE -> \n [2573:7]
30284 | | | | | |--LEADING_ASTERISK -> * [2574:0]
30285 | | | | | |--TEXT -> Verifies that the arguments of [2574:6]
30286 | | | | | |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG [2574:38]
30287 | | | | | | |--JAVADOC_INLINE_TAG_START -> { [2574:38]
30288 | | | | | | |--LINK_LITERAL -> @link [2574:39]
30289 | | | | | | |--WS -> [2574:44]
30290 | | | | | | |--REFERENCE -> REFERENCE [2574:45]
30291 | | | | | | | |--PACKAGE_CLASS -> IndentationCheck [2574:45]
30292 | | | | | | | |--HASH -> # [2574:61]
30293 | | | | | | | `--MEMBER -> MSG_ERROR [2574:62]
30294 | | | | | | `--JAVADOC_INLINE_TAG_END -> } [2574:71]
30295 | | | | | |--TEXT -> , [2574:72]
30296 | | | | | |--NEWLINE -> \n [2574:73]
30297 | | | | | |--LEADING_ASTERISK -> * [2575:0]
30298 | | | | | |--TEXT -> [2575:6]
30299 | | | | | |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG [2575:7]
30300 | | | | | | |--JAVADOC_INLINE_TAG_START -> { [2575:7]
30301 | | | | | | |--LINK_LITERAL -> @link [2575:8]
30302 | | | | | | |--WS -> [2575:13]
30303 | | | | | | |--REFERENCE -> REFERENCE [2575:14]
30304 | | | | | | | |--PACKAGE_CLASS -> IndentationCheck [2575:14]
30305 | | | | | | | |--HASH -> # [2575:30]
30306 | | | | | | | `--MEMBER -> MSG_CHILD_ERROR [2575:31]
30307 | | | | | | `--JAVADOC_INLINE_TAG_END -> } [2575:46]
30308 | | | | | |--TEXT -> , [2575:47]
30309 | | | | | |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG [2575:49]
30310 | | | | | | |--JAVADOC_INLINE_TAG_START -> { [2575:49]
30311 | | | | | | |--LINK_LITERAL -> @link [2575:50]
30312 | | | | | | |--WS -> [2575:55]
30313 | | | | | | |--REFERENCE -> REFERENCE [2575:56]
30314 | | | | | | | |--PACKAGE_CLASS -> IndentationCheck [2575:56]
30315 | | | | | | | |--HASH -> # [2575:72]
30316 | | | | | | | `--MEMBER -> MSG_CHILD_ERROR_MULTI [2575:73]
30317 | | | | | | `--JAVADOC_INLINE_TAG_END -> } [2575:94]
30318 | | | | | |--TEXT -> , [2575:95]
30319 | | | | | |--NEWLINE -> \n [2575:96]
30320 | | | | | |--LEADING_ASTERISK -> * [2576:0]
30321 | | | | | |--TEXT -> [2576:6]
30322 | | | | | |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG [2576:7]
30323 | | | | | | |--JAVADOC_INLINE_TAG_START -> { [2576:7]
30324 | | | | | | |--LINK_LITERAL -> @link [2576:8]
30325 | | | | | | |--WS -> [2576:13]
30326 | | | | | | |--REFERENCE -> REFERENCE [2576:14]
30327 | | | | | | | |--PACKAGE_CLASS -> IndentationCheck [2576:14]
30328 | | | | | | | |--HASH -> # [2576:30]
30329 | | | | | | | `--MEMBER -> MSG_CHILD_ERROR_MULTI [2576:31]
30330 | | | | | | `--JAVADOC_INLINE_TAG_END -> } [2576:52]
30331 | | | | | |--TEXT -> are in appropriate order. [2576:53]
30332 | | | | | |--NEWLINE -> \n [2576:79]
30333 | | | | | |--LEADING_ASTERISK -> * [2577:0]
30334 | | | | | |--NEWLINE -> \n [2577:6]
30335 | | | | | |--LEADING_ASTERISK -> * [2578:0]
30336 | | | | | |--TEXT -> [2578:6]
30337 | | | | | |--HTML_ELEMENT -> HTML_ELEMENT [2578:7]
30338 | | | | | | `--PARAGRAPH -> PARAGRAPH [2578:7]
30339 | | | | | | |--P_TAG_START -> P_TAG_START [2578:7]
30340 | | | | | | | |--START -> < [2578:7]
30341 | | | | | | | |--P_HTML_TAG_NAME -> p [2578:8]
30342 | | | | | | | `--END -> > [2578:9]
30343 | | | | | | |--TEXT -> In other tests, the argument 0 and text before it are chopped off and only the rest of [2578:10]
30344 | | | | | | |--NEWLINE -> \n [2578:96]
30345 | | | | | | |--LEADING_ASTERISK -> * [2579:0]
30346 | | | | | | |--TEXT -> messages are verified. Therefore, the argument 0 is required to be the first argument in [2579:6]
30347 | | | | | | |--NEWLINE -> \n [2579:95]
30348 | | | | | | |--LEADING_ASTERISK -> * [2580:0]
30349 | | | | | | |--TEXT -> the messages above. If we update the messages in the future, it is required to keep the [2580:6]
30350 | | | | | | |--NEWLINE -> \n [2580:94]
30351 | | | | | | |--LEADING_ASTERISK -> * [2581:0]
30352 | | | | | | |--TEXT -> arguments in appropriate order to ensure other tests will work. [2581:6]
30353 | | | | | | `--P_TAG_END -> P_TAG_END [2581:70]
30354 | | | | | | |--START -> < [2581:70]
30355 | | | | | | |--SLASH -> / [2581:71]
30356 | | | | | | |--P_HTML_TAG_NAME -> p [2581:72]
30357 | | | | | | `--END -> > [2581:73]
30358 | | | | | |--NEWLINE -> \n [2581:74]
30359 | | | | | |--LEADING_ASTERISK -> * [2582:0]
30360 | | | | | |--NEWLINE -> \n [2582:6]
30361 | | | | | |--LEADING_ASTERISK -> * [2583:0]
30362 | | | | | |--WS -> [2583:6]
30363 | | | | | |--JAVADOC_TAG -> JAVADOC_TAG [2583:7]
30364 | | | | | | |--SEE_LITERAL -> @see [2583:7]
30365 | | | | | | |--WS -> [2583:11]
30366 | | | | | | |--REFERENCE -> REFERENCE [2583:12]
30367 | | | | | | | |--PACKAGE_CLASS -> IndentComment [2583:12]
30368 | | | | | | | |--HASH -> # [2583:25]
30369 | | | | | | | |--MEMBER -> getExpectedMessagePostfix [2583:26]
30370 | | | | | | | `--PARAMETERS -> PARAMETERS [2583:51]
30371 | | | | | | | |--LEFT_BRACE -> ( [2583:51]
30372 | | | | | | | |--ARGUMENT -> String [2583:52]
30373 | | | | | | | `--RIGHT_BRACE -> ) [2583:58]
30374 | | | | | | |--NEWLINE -> \n [2583:59]
30375 | | | | | | `--WS -> [2584:0]
30376 | | | | | `--EOF -> <EOF> [2584:5]
30377 | | | | `--BLOCK_COMMENT_END -> */ [2584:5]
30378 | | | |--AT -> @ [2585:4]
30379 | | | `--IDENT -> Test [2585:5]
30380 | | `--LITERAL_PUBLIC -> public [2586:4]
30381 | |--TYPE -> TYPE [2586:11]
30382 | | `--LITERAL_VOID -> void [2586:11]
30383 | |--IDENT -> testArgumentOrderOfErrorMessages [2586:16]
30384 | |--LPAREN -> ( [2586:48]
30385 | |--PARAMETERS -> PARAMETERS [2586:49]
30386 | |--RPAREN -> ) [2586:49]
30387 | `--SLIST -> { [2586:51]
30388 | |--VARIABLE_DEF -> VARIABLE_DEF [2587:8]
30389 | | |--MODIFIERS -> MODIFIERS [2587:8]
30390 | | | `--FINAL -> final [2587:8]
30391 | | |--TYPE -> TYPE [2587:20]
30392 | | | `--ARRAY_DECLARATOR -> [ [2587:20]
30393 | | | |--IDENT -> Object [2587:14]
30394 | | | `--RBRACK -> ] [2587:21]
30395 | | |--IDENT -> arguments [2587:23]
30396 | | `--ASSIGN -> = [2587:33]
30397 | | `--ARRAY_INIT -> { [2587:35]
30398 | | |--EXPR -> EXPR [2587:36]
30399 | | | `--STRING_LITERAL -> "##0##" [2587:36]
30400 | | |--COMMA -> , [2587:43]
30401 | | |--EXPR -> EXPR [2587:45]
30402 | | | `--STRING_LITERAL -> "##1##" [2587:45]
30403 | | |--COMMA -> , [2587:52]
30404 | | |--EXPR -> EXPR [2587:54]
30405 | | | `--STRING_LITERAL -> "##2##" [2587:54]
30406 | | `--RCURLY -> } [2587:61]
30407 | |--SEMI -> ; [2587:62]
30408 | |--VARIABLE_DEF -> VARIABLE_DEF [2588:8]
30409 | | |--MODIFIERS -> MODIFIERS [2588:8]
30410 | | | `--FINAL -> final [2588:8]
30411 | | |--TYPE -> TYPE [2588:20]
30412 | | | `--ARRAY_DECLARATOR -> [ [2588:20]
30413 | | | |--IDENT -> String [2588:14]
30414 | | | `--RBRACK -> ] [2588:21]
30415 | | |--IDENT -> messages [2588:23]
30416 | | `--ASSIGN -> = [2588:32]
30417 | | `--ARRAY_INIT -> { [2588:34]
30418 | | |--EXPR -> EXPR [2589:27]
30419 | | | `--METHOD_CALL -> ( [2589:27]
30420 | | | |--IDENT -> getCheckMessage [2589:12]
30421 | | | |--ELIST -> ELIST [2589:28]
30422 | | | | |--EXPR -> EXPR [2589:28]
30423 | | | | | `--IDENT -> MSG_ERROR [2589:28]
30424 | | | | |--COMMA -> , [2589:37]
30425 | | | | `--EXPR -> EXPR [2589:39]
30426 | | | | `--IDENT -> arguments [2589:39]
30427 | | | `--RPAREN -> ) [2589:48]
30428 | | |--COMMA -> , [2589:49]
30429 | | |--EXPR -> EXPR [2590:27]
30430 | | | `--METHOD_CALL -> ( [2590:27]
30431 | | | |--IDENT -> getCheckMessage [2590:12]
30432 | | | |--ELIST -> ELIST [2590:28]
30433 | | | | |--EXPR -> EXPR [2590:28]
30434 | | | | | `--IDENT -> MSG_CHILD_ERROR [2590:28]
30435 | | | | |--COMMA -> , [2590:43]
30436 | | | | `--EXPR -> EXPR [2590:45]
30437 | | | | `--IDENT -> arguments [2590:45]
30438 | | | `--RPAREN -> ) [2590:54]
30439 | | |--COMMA -> , [2590:55]
30440 | | |--EXPR -> EXPR [2591:27]
30441 | | | `--METHOD_CALL -> ( [2591:27]
30442 | | | |--IDENT -> getCheckMessage [2591:12]
30443 | | | |--ELIST -> ELIST [2591:28]
30444 | | | | |--EXPR -> EXPR [2591:28]
30445 | | | | | `--IDENT -> MSG_ERROR_MULTI [2591:28]
30446 | | | | |--COMMA -> , [2591:43]
30447 | | | | `--EXPR -> EXPR [2591:45]
30448 | | | | `--IDENT -> arguments [2591:45]
30449 | | | `--RPAREN -> ) [2591:54]
30450 | | |--COMMA -> , [2591:55]
30451 | | |--EXPR -> EXPR [2592:27]
30452 | | | `--METHOD_CALL -> ( [2592:27]
30453 | | | |--IDENT -> getCheckMessage [2592:12]
30454 | | | |--ELIST -> ELIST [2592:28]
30455 | | | | |--EXPR -> EXPR [2592:28]
30456 | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [2592:28]
30457 | | | | |--COMMA -> , [2592:49]
30458 | | | | `--EXPR -> EXPR [2592:51]
30459 | | | | `--IDENT -> arguments [2592:51]
30460 | | | `--RPAREN -> ) [2592:60]
30461 | | |--COMMA -> , [2592:61]
30462 | | `--RCURLY -> } [2593:8]
30463 | |--SEMI -> ; [2593:9]
30464 | |--VARIABLE_DEF -> VARIABLE_DEF [2594:8]
30465 | | |--MODIFIERS -> MODIFIERS [2594:8]
30466 | | | `--FINAL -> final [2594:8]
30467 | | |--TYPE -> TYPE [2594:14]
30468 | | | `--LITERAL_BOOLEAN -> boolean [2594:14]
30469 | | |--IDENT -> isInOrder [2594:22]
30470 | | `--ASSIGN -> = [2594:32]
30471 | | `--EXPR -> EXPR [2594:66]
30472 | | `--METHOD_CALL -> ( [2594:66]
30473 | | |--DOT -> . [2594:57]
30474 | | | |--METHOD_CALL -> ( [2594:47]
30475 | | | | |--DOT -> . [2594:40]
30476 | | | | | |--IDENT -> Arrays [2594:34]
30477 | | | | | `--IDENT -> stream [2594:41]
30478 | | | | |--ELIST -> ELIST [2594:48]
30479 | | | | | `--EXPR -> EXPR [2594:48]
30480 | | | | | `--IDENT -> messages [2594:48]
30481 | | | | `--RPAREN -> ) [2594:56]
30482 | | | `--IDENT -> allMatch [2594:58]
30483 | | |--ELIST -> ELIST [2594:71]
30484 | | | `--LAMBDA -> -> [2594:71]
30485 | | | |--IDENT -> msg [2594:67]
30486 | | | `--SLIST -> { [2594:74]
30487 | | | |--VARIABLE_DEF -> VARIABLE_DEF [2595:12]
30488 | | | | |--MODIFIERS -> MODIFIERS [2595:12]
30489 | | | | | `--FINAL -> final [2595:12]
30490 | | | | |--TYPE -> TYPE [2595:18]
30491 | | | | | `--LITERAL_INT -> int [2595:18]
30492 | | | | |--IDENT -> indexOfArgumentZero [2595:22]
30493 | | | | `--ASSIGN -> = [2595:42]
30494 | | | | `--EXPR -> EXPR [2595:55]
30495 | | | | `--METHOD_CALL -> ( [2595:55]
30496 | | | | |--DOT -> . [2595:47]
30497 | | | | | |--IDENT -> msg [2595:44]
30498 | | | | | `--IDENT -> indexOf [2595:48]
30499 | | | | |--ELIST -> ELIST [2595:56]
30500 | | | | | `--EXPR -> EXPR [2595:56]
30501 | | | | | `--TYPECAST -> ( [2595:56]
30502 | | | | | |--TYPE -> TYPE [2595:57]
30503 | | | | | | `--IDENT -> String [2595:57]
30504 | | | | | |--RPAREN -> ) [2595:63]
30505 | | | | | `--INDEX_OP -> [ [2595:74]
30506 | | | | | |--IDENT -> arguments [2595:65]
30507 | | | | | |--EXPR -> EXPR [2595:75]
30508 | | | | | | `--NUM_INT -> 0 [2595:75]
30509 | | | | | `--RBRACK -> ] [2595:76]
30510 | | | | `--RPAREN -> ) [2595:77]
30511 | | | |--SEMI -> ; [2595:78]
30512 | | | |--LITERAL_RETURN -> return [2596:12]
30513 | | | | |--EXPR -> EXPR [2599:29]
30514 | | | | | `--METHOD_CALL -> ( [2599:29]
30515 | | | | | |--DOT -> . [2599:20]
30516 | | | | | | |--METHOD_CALL -> ( [2598:29]
30517 | | | | | | | |--DOT -> . [2598:20]
30518 | | | | | | | | |--METHOD_CALL -> ( [2597:24]
30519 | | | | | | | | | |--DOT -> . [2597:20]
30520 | | | | | | | | | | |--METHOD_CALL -> ( [2596:32]
30521 | | | | | | | | | | | |--DOT -> . [2596:25]
30522 | | | | | | | | | | | | |--IDENT -> Arrays [2596:19]
30523 | | | | | | | | | | | | `--IDENT -> stream [2596:26]
30524 | | | | | | | | | | | |--ELIST -> ELIST [2596:33]
30525 | | | | | | | | | | | | `--EXPR -> EXPR [2596:33]
30526 | | | | | | | | | | | | `--IDENT -> arguments [2596:33]
30527 | | | | | | | | | | | `--RPAREN -> ) [2596:42]
30528 | | | | | | | | | | `--IDENT -> map [2597:21]
30529 | | | | | | | | | |--ELIST -> ELIST [2597:37]
30530 | | | | | | | | | | `--EXPR -> EXPR [2597:37]
30531 | | | | | | | | | | `--METHOD_REF -> :: [2597:37]
30532 | | | | | | | | | | |--DOT -> . [2597:31]
30533 | | | | | | | | | | | |--IDENT -> String [2597:25]
30534 | | | | | | | | | | | `--LITERAL_CLASS -> class [2597:32]
30535 | | | | | | | | | | `--IDENT -> cast [2597:39]
30536 | | | | | | | | | `--RPAREN -> ) [2597:43]
30537 | | | | | | | | `--IDENT -> mapToInt [2598:21]
30538 | | | | | | | |--ELIST -> ELIST [2598:33]
30539 | | | | | | | | `--EXPR -> EXPR [2598:33]
30540 | | | | | | | | `--METHOD_REF -> :: [2598:33]
30541 | | | | | | | | |--IDENT -> msg [2598:30]
30542 | | | | | | | | `--IDENT -> indexOf [2598:35]
30543 | | | | | | | `--RPAREN -> ) [2598:42]
30544 | | | | | | `--IDENT -> allMatch [2599:21]
30545 | | | | | |--ELIST -> ELIST [2599:36]
30546 | | | | | | `--LAMBDA -> -> [2599:36]
30547 | | | | | | |--IDENT -> index [2599:30]
30548 | | | | | | `--EXPR -> EXPR [2599:45]
30549 | | | | | | `--GE -> >= [2599:45]
30550 | | | | | | |--IDENT -> index [2599:39]
30551 | | | | | | `--IDENT -> indexOfArgumentZero [2599:48]
30552 | | | | | `--RPAREN -> ) [2599:67]
30553 | | | | `--SEMI -> ; [2599:68]
30554 | | | `--RCURLY -> } [2600:8]
30555 | | `--RPAREN -> ) [2600:9]
30556 | |--SEMI -> ; [2600:10]
30557 | |--EXPR -> EXPR [2601:18]
30558 | | `--METHOD_CALL -> ( [2601:18]
30559 | | |--IDENT -> assertTrue [2601:8]
30560 | | |--ELIST -> ELIST [2601:19]
30561 | | | |--EXPR -> EXPR [2601:19]
30562 | | | | `--IDENT -> isInOrder [2601:19]
30563 | | | |--COMMA -> , [2601:28]
30564 | | | `--EXPR -> EXPR [2604:24]
30565 | | | `--PLUS -> + [2604:24]
30566 | | | |--PLUS -> + [2603:24]
30567 | | | | |--STRING_LITERAL -> "the argument 0 of error messages (indentation.error, indentation.child.error," [2602:16]
30568 | | | | `--STRING_LITERAL -> " indentation.error.multi, indentation.child.error.multi)" [2603:26]
30569 | | | `--STRING_LITERAL -> " is required to be the first argument of them" [2604:26]
30570 | | `--RPAREN -> ) [2604:73]
30571 | |--SEMI -> ; [2604:74]
30572 | `--RCURLY -> } [2605:4]
30573 |--METHOD_DEF -> METHOD_DEF [2607:4]
30574 | |--MODIFIERS -> MODIFIERS [2607:4]
30575 | | |--ANNOTATION -> ANNOTATION [2607:4]
30576 | | | |--AT -> @ [2607:4]
30577 | | | `--IDENT -> Test [2607:5]
30578 | | `--LITERAL_PUBLIC -> public [2608:4]
30579 | |--TYPE -> TYPE [2608:11]
30580 | | `--LITERAL_VOID -> void [2608:11]
30581 | |--IDENT -> testEmptyArray [2608:16]
30582 | |--LPAREN -> ( [2608:30]
30583 | |--PARAMETERS -> PARAMETERS [2608:31]
30584 | |--RPAREN -> ) [2608:31]
30585 | |--LITERAL_THROWS -> throws [2608:33]
30586 | | `--IDENT -> Exception [2608:40]
30587 | `--SLIST -> { [2608:50]
30588 | |--VARIABLE_DEF -> VARIABLE_DEF [2609:8]
30589 | | |--MODIFIERS -> MODIFIERS [2609:8]
30590 | | | `--FINAL -> final [2609:8]
30591 | | |--TYPE -> TYPE [2609:14]
30592 | | | `--IDENT -> DefaultConfiguration [2609:14]
30593 | | |--IDENT -> checkConfig [2609:35]
30594 | | `--ASSIGN -> = [2609:47]
30595 | | `--EXPR -> EXPR [2609:67]
30596 | | `--METHOD_CALL -> ( [2609:67]
30597 | | |--IDENT -> createModuleConfig [2609:49]
30598 | | |--ELIST -> ELIST [2609:84]
30599 | | | `--EXPR -> EXPR [2609:84]
30600 | | | `--DOT -> . [2609:84]
30601 | | | |--IDENT -> IndentationCheck [2609:68]
30602 | | | `--LITERAL_CLASS -> class [2609:85]
30603 | | `--RPAREN -> ) [2609:90]
30604 | |--SEMI -> ; [2609:91]
30605 | |--EXPR -> EXPR [2610:32]
30606 | | `--METHOD_CALL -> ( [2610:32]
30607 | | |--DOT -> . [2610:19]
30608 | | | |--IDENT -> checkConfig [2610:8]
30609 | | | `--IDENT -> addAttribute [2610:20]
30610 | | |--ELIST -> ELIST [2610:33]
30611 | | | |--EXPR -> EXPR [2610:33]
30612 | | | | `--STRING_LITERAL -> "tabWidth" [2610:33]
30613 | | | |--COMMA -> , [2610:43]
30614 | | | `--EXPR -> EXPR [2610:45]
30615 | | | `--STRING_LITERAL -> "4" [2610:45]
30616 | | `--RPAREN -> ) [2610:48]
30617 | |--SEMI -> ; [2610:49]
30618 | |--VARIABLE_DEF -> VARIABLE_DEF [2611:8]
30619 | | |--MODIFIERS -> MODIFIERS [2611:8]
30620 | | | `--FINAL -> final [2611:8]
30621 | | |--TYPE -> TYPE [2611:20]
30622 | | | `--ARRAY_DECLARATOR -> [ [2611:20]
30623 | | | |--IDENT -> String [2611:14]
30624 | | | `--RBRACK -> ] [2611:21]
30625 | | |--IDENT -> expected [2611:23]
30626 | | `--ASSIGN -> = [2611:32]
30627 | | `--EXPR -> EXPR [2611:44]
30628 | | `--DOT -> . [2611:44]
30629 | | |--IDENT -> CommonUtil [2611:34]
30630 | | `--IDENT -> EMPTY_STRING_ARRAY [2611:45]
30631 | |--SEMI -> ; [2611:63]
30632 | |--EXPR -> EXPR [2612:19]
30633 | | `--METHOD_CALL -> ( [2612:19]
30634 | | |--IDENT -> verifyWarns [2612:8]
30635 | | |--ELIST -> ELIST [2612:20]
30636 | | | |--EXPR -> EXPR [2612:20]
30637 | | | | `--IDENT -> checkConfig [2612:20]
30638 | | | |--COMMA -> , [2612:31]
30639 | | | |--EXPR -> EXPR [2612:40]
30640 | | | | `--METHOD_CALL -> ( [2612:40]
30641 | | | | |--IDENT -> getPath [2612:33]
30642 | | | | |--ELIST -> ELIST [2612:41]
30643 | | | | | `--EXPR -> EXPR [2612:41]
30644 | | | | | `--STRING_LITERAL -> "InputIndentationEmptyArray.java" [2612:41]
30645 | | | | `--RPAREN -> ) [2612:74]
30646 | | | |--COMMA -> , [2612:75]
30647 | | | `--EXPR -> EXPR [2612:77]
30648 | | | `--IDENT -> expected [2612:77]
30649 | | `--RPAREN -> ) [2612:85]
30650 | |--SEMI -> ; [2612:86]
30651 | `--RCURLY -> } [2613:4]
30652 |--METHOD_DEF -> METHOD_DEF [2615:4]
30653 | |--MODIFIERS -> MODIFIERS [2615:4]
30654 | | |--ANNOTATION -> ANNOTATION [2615:4]
30655 | | | |--AT -> @ [2615:4]
30656 | | | `--IDENT -> Test [2615:5]
30657 | | `--LITERAL_PUBLIC -> public [2616:4]
30658 | |--TYPE -> TYPE [2616:11]
30659 | | `--LITERAL_VOID -> void [2616:11]
30660 | |--IDENT -> testNewHandler [2616:16]
30661 | |--LPAREN -> ( [2616:30]
30662 | |--PARAMETERS -> PARAMETERS [2616:31]
30663 | |--RPAREN -> ) [2616:31]
30664 | |--LITERAL_THROWS -> throws [2616:33]
30665 | | `--IDENT -> Exception [2616:40]
30666 | `--SLIST -> { [2616:50]
30667 | |--VARIABLE_DEF -> VARIABLE_DEF [2617:8]
30668 | | |--MODIFIERS -> MODIFIERS [2617:8]
30669 | | | `--FINAL -> final [2617:8]
30670 | | |--TYPE -> TYPE [2617:14]
30671 | | | `--IDENT -> DefaultConfiguration [2617:14]
30672 | | |--IDENT -> checkConfig [2617:35]
30673 | | `--ASSIGN -> = [2617:47]
30674 | | `--EXPR -> EXPR [2617:67]
30675 | | `--METHOD_CALL -> ( [2617:67]
30676 | | |--IDENT -> createModuleConfig [2617:49]
30677 | | |--ELIST -> ELIST [2617:84]
30678 | | | `--EXPR -> EXPR [2617:84]
30679 | | | `--DOT -> . [2617:84]
30680 | | | |--IDENT -> IndentationCheck [2617:68]
30681 | | | `--LITERAL_CLASS -> class [2617:85]
30682 | | `--RPAREN -> ) [2617:90]
30683 | |--SEMI -> ; [2617:91]
30684 | |--EXPR -> EXPR [2618:32]
30685 | | `--METHOD_CALL -> ( [2618:32]
30686 | | |--DOT -> . [2618:19]
30687 | | | |--IDENT -> checkConfig [2618:8]
30688 | | | `--IDENT -> addAttribute [2618:20]
30689 | | |--ELIST -> ELIST [2618:33]
30690 | | | |--EXPR -> EXPR [2618:33]
30691 | | | | `--STRING_LITERAL -> "tabWidth" [2618:33]
30692 | | | |--COMMA -> , [2618:43]
30693 | | | `--EXPR -> EXPR [2618:45]
30694 | | | `--STRING_LITERAL -> "4" [2618:45]
30695 | | `--RPAREN -> ) [2618:48]
30696 | |--SEMI -> ; [2618:49]
30697 | |--VARIABLE_DEF -> VARIABLE_DEF [2619:8]
30698 | | |--MODIFIERS -> MODIFIERS [2619:8]
30699 | | | `--FINAL -> final [2619:8]
30700 | | |--TYPE -> TYPE [2619:20]
30701 | | | `--ARRAY_DECLARATOR -> [ [2619:20]
30702 | | | |--IDENT -> String [2619:14]
30703 | | | `--RBRACK -> ] [2619:21]
30704 | | |--IDENT -> expected [2619:23]
30705 | | `--ASSIGN -> = [2619:32]
30706 | | `--ARRAY_INIT -> { [2619:34]
30707 | | |--EXPR -> EXPR [2620:21]
30708 | | | `--PLUS -> + [2620:21]
30709 | | | |--STRING_LITERAL -> "10:1: " [2620:12]
30710 | | | `--METHOD_CALL -> ( [2620:38]
30711 | | | |--IDENT -> getCheckMessage [2620:23]
30712 | | | |--ELIST -> ELIST [2620:39]
30713 | | | | |--EXPR -> EXPR [2620:39]
30714 | | | | | `--IDENT -> MSG_ERROR [2620:39]
30715 | | | | |--COMMA -> , [2620:48]
30716 | | | | |--EXPR -> EXPR [2620:50]
30717 | | | | | `--STRING_LITERAL -> "Object" [2620:50]
30718 | | | | |--COMMA -> , [2620:58]
30719 | | | | |--EXPR -> EXPR [2620:60]
30720 | | | | | `--NUM_INT -> 0 [2620:60]
30721 | | | | |--COMMA -> , [2620:61]
30722 | | | | `--EXPR -> EXPR [2620:63]
30723 | | | | `--NUM_INT -> 12 [2620:63]
30724 | | | `--RPAREN -> ) [2620:65]
30725 | | |--COMMA -> , [2620:66]
30726 | | |--EXPR -> EXPR [2621:21]
30727 | | | `--PLUS -> + [2621:21]
30728 | | | |--STRING_LITERAL -> "12:1: " [2621:12]
30729 | | | `--METHOD_CALL -> ( [2621:38]
30730 | | | |--IDENT -> getCheckMessage [2621:23]
30731 | | | |--ELIST -> ELIST [2621:39]
30732 | | | | |--EXPR -> EXPR [2621:39]
30733 | | | | | `--IDENT -> MSG_ERROR [2621:39]
30734 | | | | |--COMMA -> , [2621:48]
30735 | | | | |--EXPR -> EXPR [2621:50]
30736 | | | | | `--STRING_LITERAL -> "(" [2621:50]
30737 | | | | |--COMMA -> , [2621:53]
30738 | | | | |--EXPR -> EXPR [2621:55]
30739 | | | | | `--NUM_INT -> 0 [2621:55]
30740 | | | | |--COMMA -> , [2621:56]
30741 | | | | `--EXPR -> EXPR [2621:58]
30742 | | | | `--NUM_INT -> 12 [2621:58]
30743 | | | `--RPAREN -> ) [2621:60]
30744 | | |--COMMA -> , [2621:61]
30745 | | |--EXPR -> EXPR [2622:21]
30746 | | | `--PLUS -> + [2622:21]
30747 | | | |--STRING_LITERAL -> "15:1: " [2622:12]
30748 | | | `--METHOD_CALL -> ( [2622:38]
30749 | | | |--IDENT -> getCheckMessage [2622:23]
30750 | | | |--ELIST -> ELIST [2622:39]
30751 | | | | |--EXPR -> EXPR [2622:39]
30752 | | | | | `--IDENT -> MSG_CHILD_ERROR [2622:39]
30753 | | | | |--COMMA -> , [2622:54]
30754 | | | | |--EXPR -> EXPR [2622:56]
30755 | | | | | `--STRING_LITERAL -> "new" [2622:56]
30756 | | | | |--COMMA -> , [2622:61]
30757 | | | | |--EXPR -> EXPR [2622:63]
30758 | | | | | `--NUM_INT -> 0 [2622:63]
30759 | | | | |--COMMA -> , [2622:64]
30760 | | | | `--EXPR -> EXPR [2622:66]
30761 | | | | `--NUM_INT -> 8 [2622:66]
30762 | | | `--RPAREN -> ) [2622:67]
30763 | | |--COMMA -> , [2622:68]
30764 | | |--EXPR -> EXPR [2623:21]
30765 | | | `--PLUS -> + [2623:21]
30766 | | | |--STRING_LITERAL -> "17:1: " [2623:12]
30767 | | | `--METHOD_CALL -> ( [2623:38]
30768 | | | |--IDENT -> getCheckMessage [2623:23]
30769 | | | |--ELIST -> ELIST [2623:39]
30770 | | | | |--EXPR -> EXPR [2623:39]
30771 | | | | | `--IDENT -> MSG_ERROR [2623:39]
30772 | | | | |--COMMA -> , [2623:48]
30773 | | | | |--EXPR -> EXPR [2623:50]
30774 | | | | | `--STRING_LITERAL -> "new lparen" [2623:50]
30775 | | | | |--COMMA -> , [2623:62]
30776 | | | | |--EXPR -> EXPR [2623:64]
30777 | | | | | `--NUM_INT -> 0 [2623:64]
30778 | | | | |--COMMA -> , [2623:65]
30779 | | | | `--EXPR -> EXPR [2623:67]
30780 | | | | `--NUM_INT -> 8 [2623:67]
30781 | | | `--RPAREN -> ) [2623:68]
30782 | | |--COMMA -> , [2623:69]
30783 | | `--RCURLY -> } [2624:8]
30784 | |--SEMI -> ; [2624:9]
30785 | |--EXPR -> EXPR [2625:19]
30786 | | `--METHOD_CALL -> ( [2625:19]
30787 | | |--IDENT -> verifyWarns [2625:8]
30788 | | |--ELIST -> ELIST [2625:20]
30789 | | | |--EXPR -> EXPR [2625:20]
30790 | | | | `--IDENT -> checkConfig [2625:20]
30791 | | | |--COMMA -> , [2625:31]
30792 | | | |--EXPR -> EXPR [2625:40]
30793 | | | | `--METHOD_CALL -> ( [2625:40]
30794 | | | | |--IDENT -> getPath [2625:33]
30795 | | | | |--ELIST -> ELIST [2625:41]
30796 | | | | | `--EXPR -> EXPR [2625:41]
30797 | | | | | `--STRING_LITERAL -> "InputIndentationNewHandler.java" [2625:41]
30798 | | | | `--RPAREN -> ) [2625:74]
30799 | | | |--COMMA -> , [2625:75]
30800 | | | `--EXPR -> EXPR [2625:77]
30801 | | | `--IDENT -> expected [2625:77]
30802 | | `--RPAREN -> ) [2625:85]
30803 | |--SEMI -> ; [2625:86]
30804 | `--RCURLY -> } [2626:4]
30805 |--METHOD_DEF -> METHOD_DEF [2628:4]
30806 | |--MODIFIERS -> MODIFIERS [2628:4]
30807 | | |--ANNOTATION -> ANNOTATION [2628:4]
30808 | | | |--AT -> @ [2628:4]
30809 | | | `--IDENT -> Test [2628:5]
30810 | | `--LITERAL_PUBLIC -> public [2629:4]
30811 | |--TYPE -> TYPE [2629:11]
30812 | | `--LITERAL_VOID -> void [2629:11]
30813 | |--IDENT -> testTryHandler [2629:16]
30814 | |--LPAREN -> ( [2629:30]
30815 | |--PARAMETERS -> PARAMETERS [2629:31]
30816 | |--RPAREN -> ) [2629:31]
30817 | |--LITERAL_THROWS -> throws [2629:33]
30818 | | `--IDENT -> Exception [2629:40]
30819 | `--SLIST -> { [2629:50]
30820 | |--VARIABLE_DEF -> VARIABLE_DEF [2630:8]
30821 | | |--MODIFIERS -> MODIFIERS [2630:8]
30822 | | | `--FINAL -> final [2630:8]
30823 | | |--TYPE -> TYPE [2630:14]
30824 | | | `--IDENT -> DefaultConfiguration [2630:14]
30825 | | |--IDENT -> checkConfig [2630:35]
30826 | | `--ASSIGN -> = [2630:47]
30827 | | `--EXPR -> EXPR [2630:67]
30828 | | `--METHOD_CALL -> ( [2630:67]
30829 | | |--IDENT -> createModuleConfig [2630:49]
30830 | | |--ELIST -> ELIST [2630:84]
30831 | | | `--EXPR -> EXPR [2630:84]
30832 | | | `--DOT -> . [2630:84]
30833 | | | |--IDENT -> IndentationCheck [2630:68]
30834 | | | `--LITERAL_CLASS -> class [2630:85]
30835 | | `--RPAREN -> ) [2630:90]
30836 | |--SEMI -> ; [2630:91]
30837 | |--EXPR -> EXPR [2631:32]
30838 | | `--METHOD_CALL -> ( [2631:32]
30839 | | |--DOT -> . [2631:19]
30840 | | | |--IDENT -> checkConfig [2631:8]
30841 | | | `--IDENT -> addAttribute [2631:20]
30842 | | |--ELIST -> ELIST [2631:33]
30843 | | | |--EXPR -> EXPR [2631:33]
30844 | | | | `--STRING_LITERAL -> "tabWidth" [2631:33]
30845 | | | |--COMMA -> , [2631:43]
30846 | | | `--EXPR -> EXPR [2631:45]
30847 | | | `--STRING_LITERAL -> "4" [2631:45]
30848 | | `--RPAREN -> ) [2631:48]
30849 | |--SEMI -> ; [2631:49]
30850 | |--EXPR -> EXPR [2632:32]
30851 | | `--METHOD_CALL -> ( [2632:32]
30852 | | |--DOT -> . [2632:19]
30853 | | | |--IDENT -> checkConfig [2632:8]
30854 | | | `--IDENT -> addAttribute [2632:20]
30855 | | |--ELIST -> ELIST [2632:33]
30856 | | | |--EXPR -> EXPR [2632:33]
30857 | | | | `--STRING_LITERAL -> "braceAdjustment" [2632:33]
30858 | | | |--COMMA -> , [2632:50]
30859 | | | `--EXPR -> EXPR [2632:52]
30860 | | | `--STRING_LITERAL -> "0" [2632:52]
30861 | | `--RPAREN -> ) [2632:55]
30862 | |--SEMI -> ; [2632:56]
30863 | |--EXPR -> EXPR [2633:32]
30864 | | `--METHOD_CALL -> ( [2633:32]
30865 | | |--DOT -> . [2633:19]
30866 | | | |--IDENT -> checkConfig [2633:8]
30867 | | | `--IDENT -> addAttribute [2633:20]
30868 | | |--ELIST -> ELIST [2633:33]
30869 | | | |--EXPR -> EXPR [2633:33]
30870 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2633:33]
30871 | | | |--COMMA -> , [2633:58]
30872 | | | `--EXPR -> EXPR [2633:60]
30873 | | | `--STRING_LITERAL -> "8" [2633:60]
30874 | | `--RPAREN -> ) [2633:63]
30875 | |--SEMI -> ; [2633:64]
30876 | |--EXPR -> EXPR [2634:32]
30877 | | `--METHOD_CALL -> ( [2634:32]
30878 | | |--DOT -> . [2634:19]
30879 | | | |--IDENT -> checkConfig [2634:8]
30880 | | | `--IDENT -> addAttribute [2634:20]
30881 | | |--ELIST -> ELIST [2634:33]
30882 | | | |--EXPR -> EXPR [2634:33]
30883 | | | | `--STRING_LITERAL -> "forceStrictCondition" [2634:33]
30884 | | | |--COMMA -> , [2634:55]
30885 | | | `--EXPR -> EXPR [2634:57]
30886 | | | `--STRING_LITERAL -> "true" [2634:57]
30887 | | `--RPAREN -> ) [2634:63]
30888 | |--SEMI -> ; [2634:64]
30889 | |--VARIABLE_DEF -> VARIABLE_DEF [2635:8]
30890 | | |--MODIFIERS -> MODIFIERS [2635:8]
30891 | | | `--FINAL -> final [2635:8]
30892 | | |--TYPE -> TYPE [2635:20]
30893 | | | `--ARRAY_DECLARATOR -> [ [2635:20]
30894 | | | |--IDENT -> String [2635:14]
30895 | | | `--RBRACK -> ] [2635:21]
30896 | | |--IDENT -> expected [2635:23]
30897 | | `--ASSIGN -> = [2635:32]
30898 | | `--EXPR -> EXPR [2635:44]
30899 | | `--DOT -> . [2635:44]
30900 | | |--IDENT -> CommonUtil [2635:34]
30901 | | `--IDENT -> EMPTY_STRING_ARRAY [2635:45]
30902 | |--SEMI -> ; [2635:63]
30903 | |--EXPR -> EXPR [2636:19]
30904 | | `--METHOD_CALL -> ( [2636:19]
30905 | | |--IDENT -> verifyWarns [2636:8]
30906 | | |--ELIST -> ELIST [2636:20]
30907 | | | |--EXPR -> EXPR [2636:20]
30908 | | | | `--IDENT -> checkConfig [2636:20]
30909 | | | |--COMMA -> , [2636:31]
30910 | | | |--EXPR -> EXPR [2636:40]
30911 | | | | `--METHOD_CALL -> ( [2636:40]
30912 | | | | |--IDENT -> getPath [2636:33]
30913 | | | | |--ELIST -> ELIST [2636:41]
30914 | | | | | `--EXPR -> EXPR [2636:41]
30915 | | | | | `--STRING_LITERAL -> "InputIndentationTryBlockWithResources.java" [2636:41]
30916 | | | | `--RPAREN -> ) [2636:85]
30917 | | | |--COMMA -> , [2636:86]
30918 | | | `--EXPR -> EXPR [2636:88]
30919 | | | `--IDENT -> expected [2636:88]
30920 | | `--RPAREN -> ) [2636:96]
30921 | |--SEMI -> ; [2636:97]
30922 | `--RCURLY -> } [2637:4]
30923 |--METHOD_DEF -> METHOD_DEF [2639:4]
30924 | |--MODIFIERS -> MODIFIERS [2639:4]
30925 | | |--ANNOTATION -> ANNOTATION [2639:4]
30926 | | | |--AT -> @ [2639:4]
30927 | | | `--IDENT -> Test [2639:5]
30928 | | `--LITERAL_PUBLIC -> public [2640:4]
30929 | |--TYPE -> TYPE [2640:11]
30930 | | `--LITERAL_VOID -> void [2640:11]
30931 | |--IDENT -> testTryHandler2 [2640:16]
30932 | |--LPAREN -> ( [2640:31]
30933 | |--PARAMETERS -> PARAMETERS [2640:32]
30934 | |--RPAREN -> ) [2640:32]
30935 | |--LITERAL_THROWS -> throws [2640:34]
30936 | | `--IDENT -> Exception [2640:41]
30937 | `--SLIST -> { [2640:51]
30938 | |--VARIABLE_DEF -> VARIABLE_DEF [2641:8]
30939 | | |--MODIFIERS -> MODIFIERS [2641:8]
30940 | | | `--FINAL -> final [2641:8]
30941 | | |--TYPE -> TYPE [2641:14]
30942 | | | `--IDENT -> DefaultConfiguration [2641:14]
30943 | | |--IDENT -> checkConfig [2641:35]
30944 | | `--ASSIGN -> = [2641:47]
30945 | | `--EXPR -> EXPR [2641:67]
30946 | | `--METHOD_CALL -> ( [2641:67]
30947 | | |--IDENT -> createModuleConfig [2641:49]
30948 | | |--ELIST -> ELIST [2641:84]
30949 | | | `--EXPR -> EXPR [2641:84]
30950 | | | `--DOT -> . [2641:84]
30951 | | | |--IDENT -> IndentationCheck [2641:68]
30952 | | | `--LITERAL_CLASS -> class [2641:85]
30953 | | `--RPAREN -> ) [2641:90]
30954 | |--SEMI -> ; [2641:91]
30955 | |--EXPR -> EXPR [2642:32]
30956 | | `--METHOD_CALL -> ( [2642:32]
30957 | | |--DOT -> . [2642:19]
30958 | | | |--IDENT -> checkConfig [2642:8]
30959 | | | `--IDENT -> addAttribute [2642:20]
30960 | | |--ELIST -> ELIST [2642:33]
30961 | | | |--EXPR -> EXPR [2642:33]
30962 | | | | `--STRING_LITERAL -> "tabWidth" [2642:33]
30963 | | | |--COMMA -> , [2642:43]
30964 | | | `--EXPR -> EXPR [2642:45]
30965 | | | `--STRING_LITERAL -> "4" [2642:45]
30966 | | `--RPAREN -> ) [2642:48]
30967 | |--SEMI -> ; [2642:49]
30968 | |--EXPR -> EXPR [2643:32]
30969 | | `--METHOD_CALL -> ( [2643:32]
30970 | | |--DOT -> . [2643:19]
30971 | | | |--IDENT -> checkConfig [2643:8]
30972 | | | `--IDENT -> addAttribute [2643:20]
30973 | | |--ELIST -> ELIST [2643:33]
30974 | | | |--EXPR -> EXPR [2643:33]
30975 | | | | `--STRING_LITERAL -> "braceAdjustment" [2643:33]
30976 | | | |--COMMA -> , [2643:50]
30977 | | | `--EXPR -> EXPR [2643:52]
30978 | | | `--STRING_LITERAL -> "0" [2643:52]
30979 | | `--RPAREN -> ) [2643:55]
30980 | |--SEMI -> ; [2643:56]
30981 | |--EXPR -> EXPR [2644:32]
30982 | | `--METHOD_CALL -> ( [2644:32]
30983 | | |--DOT -> . [2644:19]
30984 | | | |--IDENT -> checkConfig [2644:8]
30985 | | | `--IDENT -> addAttribute [2644:20]
30986 | | |--ELIST -> ELIST [2644:33]
30987 | | | |--EXPR -> EXPR [2644:33]
30988 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2644:33]
30989 | | | |--COMMA -> , [2644:58]
30990 | | | `--EXPR -> EXPR [2644:60]
30991 | | | `--STRING_LITERAL -> "8" [2644:60]
30992 | | `--RPAREN -> ) [2644:63]
30993 | |--SEMI -> ; [2644:64]
30994 | |--EXPR -> EXPR [2645:32]
30995 | | `--METHOD_CALL -> ( [2645:32]
30996 | | |--DOT -> . [2645:19]
30997 | | | |--IDENT -> checkConfig [2645:8]
30998 | | | `--IDENT -> addAttribute [2645:20]
30999 | | |--ELIST -> ELIST [2645:33]
31000 | | | |--EXPR -> EXPR [2645:33]
31001 | | | | `--STRING_LITERAL -> "forceStrictCondition" [2645:33]
31002 | | | |--COMMA -> , [2645:55]
31003 | | | `--EXPR -> EXPR [2645:57]
31004 | | | `--STRING_LITERAL -> "true" [2645:57]
31005 | | `--RPAREN -> ) [2645:63]
31006 | |--SEMI -> ; [2645:64]
31007 | |--VARIABLE_DEF -> VARIABLE_DEF [2646:8]
31008 | | |--MODIFIERS -> MODIFIERS [2646:8]
31009 | | | `--FINAL -> final [2646:8]
31010 | | |--TYPE -> TYPE [2646:20]
31011 | | | `--ARRAY_DECLARATOR -> [ [2646:20]
31012 | | | |--IDENT -> String [2646:14]
31013 | | | `--RBRACK -> ] [2646:21]
31014 | | |--IDENT -> expected [2646:23]
31015 | | `--ASSIGN -> = [2646:32]
31016 | | `--ARRAY_INIT -> { [2646:34]
31017 | | |--EXPR -> EXPR [2647:22]
31018 | | | `--PLUS -> + [2647:22]
31019 | | | |--STRING_LITERAL -> "25:17: " [2647:12]
31020 | | | `--METHOD_CALL -> ( [2647:39]
31021 | | | |--IDENT -> getCheckMessage [2647:24]
31022 | | | |--ELIST -> ELIST [2647:40]
31023 | | | | |--EXPR -> EXPR [2647:40]
31024 | | | | | `--IDENT -> MSG_ERROR [2647:40]
31025 | | | | |--COMMA -> , [2647:49]
31026 | | | | |--EXPR -> EXPR [2647:51]
31027 | | | | | `--STRING_LITERAL -> "new" [2647:51]
31028 | | | | |--COMMA -> , [2647:56]
31029 | | | | |--EXPR -> EXPR [2647:58]
31030 | | | | | `--NUM_INT -> 16 [2647:58]
31031 | | | | |--COMMA -> , [2647:60]
31032 | | | | `--EXPR -> EXPR [2647:62]
31033 | | | | `--NUM_INT -> 20 [2647:62]
31034 | | | `--RPAREN -> ) [2647:64]
31035 | | |--COMMA -> , [2647:65]
31036 | | |--EXPR -> EXPR [2648:22]
31037 | | | `--PLUS -> + [2648:22]
31038 | | | |--STRING_LITERAL -> "27:13: " [2648:12]
31039 | | | `--METHOD_CALL -> ( [2648:39]
31040 | | | |--IDENT -> getCheckMessage [2648:24]
31041 | | | |--ELIST -> ELIST [2648:40]
31042 | | | | |--EXPR -> EXPR [2648:40]
31043 | | | | | `--IDENT -> MSG_ERROR [2648:40]
31044 | | | | |--COMMA -> , [2648:49]
31045 | | | | |--EXPR -> EXPR [2648:51]
31046 | | | | | `--STRING_LITERAL -> "new" [2648:51]
31047 | | | | |--COMMA -> , [2648:56]
31048 | | | | |--EXPR -> EXPR [2648:58]
31049 | | | | | `--NUM_INT -> 12 [2648:58]
31050 | | | | |--COMMA -> , [2648:60]
31051 | | | | `--EXPR -> EXPR [2648:62]
31052 | | | | `--NUM_INT -> 20 [2648:62]
31053 | | | `--RPAREN -> ) [2648:64]
31054 | | |--COMMA -> , [2648:65]
31055 | | `--RCURLY -> } [2649:8]
31056 | |--SEMI -> ; [2649:9]
31057 | |--EXPR -> EXPR [2650:19]
31058 | | `--METHOD_CALL -> ( [2650:19]
31059 | | |--IDENT -> verifyWarns [2650:8]
31060 | | |--ELIST -> ELIST [2650:20]
31061 | | | |--EXPR -> EXPR [2650:20]
31062 | | | | `--IDENT -> checkConfig [2650:20]
31063 | | | |--COMMA -> , [2650:31]
31064 | | | |--EXPR -> EXPR [2650:40]
31065 | | | | `--METHOD_CALL -> ( [2650:40]
31066 | | | | |--IDENT -> getPath [2650:33]
31067 | | | | |--ELIST -> ELIST [2650:41]
31068 | | | | | `--EXPR -> EXPR [2650:41]
31069 | | | | | `--STRING_LITERAL -> "InputIndentationTryBlock.java" [2650:41]
31070 | | | | `--RPAREN -> ) [2650:72]
31071 | | | |--COMMA -> , [2650:73]
31072 | | | `--EXPR -> EXPR [2650:75]
31073 | | | `--IDENT -> expected [2650:75]
31074 | | `--RPAREN -> ) [2650:83]
31075 | |--SEMI -> ; [2650:84]
31076 | `--RCURLY -> } [2651:4]
31077 |--METHOD_DEF -> METHOD_DEF [2653:4]
31078 | |--MODIFIERS -> MODIFIERS [2653:4]
31079 | | |--ANNOTATION -> ANNOTATION [2653:4]
31080 | | | |--AT -> @ [2653:4]
31081 | | | `--IDENT -> Test [2653:5]
31082 | | `--LITERAL_PUBLIC -> public [2654:4]
31083 | |--TYPE -> TYPE [2654:11]
31084 | | `--LITERAL_VOID -> void [2654:11]
31085 | |--IDENT -> testChainedMethodWithBracketOnNewLine [2654:16]
31086 | |--LPAREN -> ( [2654:53]
31087 | |--PARAMETERS -> PARAMETERS [2654:54]
31088 | |--RPAREN -> ) [2654:54]
31089 | |--LITERAL_THROWS -> throws [2654:56]
31090 | | `--IDENT -> Exception [2654:63]
31091 | `--SLIST -> { [2654:73]
31092 | |--VARIABLE_DEF -> VARIABLE_DEF [2655:8]
31093 | | |--MODIFIERS -> MODIFIERS [2655:8]
31094 | | | `--FINAL -> final [2655:8]
31095 | | |--TYPE -> TYPE [2655:14]
31096 | | | `--IDENT -> DefaultConfiguration [2655:14]
31097 | | |--IDENT -> checkConfig [2655:35]
31098 | | `--ASSIGN -> = [2655:47]
31099 | | `--EXPR -> EXPR [2655:67]
31100 | | `--METHOD_CALL -> ( [2655:67]
31101 | | |--IDENT -> createModuleConfig [2655:49]
31102 | | |--ELIST -> ELIST [2655:84]
31103 | | | `--EXPR -> EXPR [2655:84]
31104 | | | `--DOT -> . [2655:84]
31105 | | | |--IDENT -> IndentationCheck [2655:68]
31106 | | | `--LITERAL_CLASS -> class [2655:85]
31107 | | `--RPAREN -> ) [2655:90]
31108 | |--SEMI -> ; [2655:91]
31109 | |--EXPR -> EXPR [2657:32]
31110 | | `--METHOD_CALL -> ( [2657:32]
31111 | | |--DOT -> . [2657:19]
31112 | | | |--IDENT -> checkConfig [2657:8]
31113 | | | `--IDENT -> addAttribute [2657:20]
31114 | | |--ELIST -> ELIST [2657:33]
31115 | | | |--EXPR -> EXPR [2657:33]
31116 | | | | `--STRING_LITERAL -> "arrayInitIndent" [2657:33]
31117 | | | |--COMMA -> , [2657:50]
31118 | | | `--EXPR -> EXPR [2657:52]
31119 | | | `--STRING_LITERAL -> "2" [2657:52]
31120 | | `--RPAREN -> ) [2657:55]
31121 | |--SEMI -> ; [2657:56]
31122 | |--EXPR -> EXPR [2658:32]
31123 | | `--METHOD_CALL -> ( [2658:32]
31124 | | |--DOT -> . [2658:19]
31125 | | | |--IDENT -> checkConfig [2658:8]
31126 | | | `--IDENT -> addAttribute [2658:20]
31127 | | |--ELIST -> ELIST [2658:33]
31128 | | | |--EXPR -> EXPR [2658:33]
31129 | | | | `--STRING_LITERAL -> "basicOffset" [2658:33]
31130 | | | |--COMMA -> , [2658:46]
31131 | | | `--EXPR -> EXPR [2658:48]
31132 | | | `--STRING_LITERAL -> "2" [2658:48]
31133 | | `--RPAREN -> ) [2658:51]
31134 | |--SEMI -> ; [2658:52]
31135 | |--EXPR -> EXPR [2659:32]
31136 | | `--METHOD_CALL -> ( [2659:32]
31137 | | |--DOT -> . [2659:19]
31138 | | | |--IDENT -> checkConfig [2659:8]
31139 | | | `--IDENT -> addAttribute [2659:20]
31140 | | |--ELIST -> ELIST [2659:33]
31141 | | | |--EXPR -> EXPR [2659:33]
31142 | | | | `--STRING_LITERAL -> "braceAdjustment" [2659:33]
31143 | | | |--COMMA -> , [2659:50]
31144 | | | `--EXPR -> EXPR [2659:52]
31145 | | | `--STRING_LITERAL -> "0" [2659:52]
31146 | | `--RPAREN -> ) [2659:55]
31147 | |--SEMI -> ; [2659:56]
31148 | |--EXPR -> EXPR [2660:32]
31149 | | `--METHOD_CALL -> ( [2660:32]
31150 | | |--DOT -> . [2660:19]
31151 | | | |--IDENT -> checkConfig [2660:8]
31152 | | | `--IDENT -> addAttribute [2660:20]
31153 | | |--ELIST -> ELIST [2660:33]
31154 | | | |--EXPR -> EXPR [2660:33]
31155 | | | | `--STRING_LITERAL -> "caseIndent" [2660:33]
31156 | | | |--COMMA -> , [2660:45]
31157 | | | `--EXPR -> EXPR [2660:47]
31158 | | | `--STRING_LITERAL -> "2" [2660:47]
31159 | | `--RPAREN -> ) [2660:50]
31160 | |--SEMI -> ; [2660:51]
31161 | |--EXPR -> EXPR [2661:32]
31162 | | `--METHOD_CALL -> ( [2661:32]
31163 | | |--DOT -> . [2661:19]
31164 | | | |--IDENT -> checkConfig [2661:8]
31165 | | | `--IDENT -> addAttribute [2661:20]
31166 | | |--ELIST -> ELIST [2661:33]
31167 | | | |--EXPR -> EXPR [2661:33]
31168 | | | | `--STRING_LITERAL -> "forceStrictCondition" [2661:33]
31169 | | | |--COMMA -> , [2661:55]
31170 | | | `--EXPR -> EXPR [2661:57]
31171 | | | `--STRING_LITERAL -> "false" [2661:57]
31172 | | `--RPAREN -> ) [2661:64]
31173 | |--SEMI -> ; [2661:65]
31174 | |--EXPR -> EXPR [2662:32]
31175 | | `--METHOD_CALL -> ( [2662:32]
31176 | | |--DOT -> . [2662:19]
31177 | | | |--IDENT -> checkConfig [2662:8]
31178 | | | `--IDENT -> addAttribute [2662:20]
31179 | | |--ELIST -> ELIST [2662:33]
31180 | | | |--EXPR -> EXPR [2662:33]
31181 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2662:33]
31182 | | | |--COMMA -> , [2662:58]
31183 | | | `--EXPR -> EXPR [2662:60]
31184 | | | `--STRING_LITERAL -> "4" [2662:60]
31185 | | `--RPAREN -> ) [2662:63]
31186 | |--SEMI -> ; [2662:64]
31187 | |--EXPR -> EXPR [2663:32]
31188 | | `--METHOD_CALL -> ( [2663:32]
31189 | | |--DOT -> . [2663:19]
31190 | | | |--IDENT -> checkConfig [2663:8]
31191 | | | `--IDENT -> addAttribute [2663:20]
31192 | | |--ELIST -> ELIST [2663:33]
31193 | | | |--EXPR -> EXPR [2663:33]
31194 | | | | `--STRING_LITERAL -> "tabWidth" [2663:33]
31195 | | | |--COMMA -> , [2663:43]
31196 | | | `--EXPR -> EXPR [2663:45]
31197 | | | `--STRING_LITERAL -> "2" [2663:45]
31198 | | `--RPAREN -> ) [2663:48]
31199 | |--SEMI -> ; [2663:49]
31200 | |--EXPR -> EXPR [2664:32]
31201 | | `--METHOD_CALL -> ( [2664:32]
31202 | | |--DOT -> . [2664:19]
31203 | | | |--IDENT -> checkConfig [2664:8]
31204 | | | `--IDENT -> addAttribute [2664:20]
31205 | | |--ELIST -> ELIST [2664:33]
31206 | | | |--EXPR -> EXPR [2664:33]
31207 | | | | `--STRING_LITERAL -> "throwsIndent" [2664:33]
31208 | | | |--COMMA -> , [2664:47]
31209 | | | `--EXPR -> EXPR [2664:49]
31210 | | | `--STRING_LITERAL -> "2" [2664:49]
31211 | | `--RPAREN -> ) [2664:52]
31212 | |--SEMI -> ; [2664:53]
31213 | |--VARIABLE_DEF -> VARIABLE_DEF [2665:8]
31214 | | |--MODIFIERS -> MODIFIERS [2665:8]
31215 | | | `--FINAL -> final [2665:8]
31216 | | |--TYPE -> TYPE [2665:20]
31217 | | | `--ARRAY_DECLARATOR -> [ [2665:20]
31218 | | | |--IDENT -> String [2665:14]
31219 | | | `--RBRACK -> ] [2665:21]
31220 | | |--IDENT -> expected [2665:23]
31221 | | `--ASSIGN -> = [2665:32]
31222 | | `--ARRAY_INIT -> { [2665:34]
31223 | | |--EXPR -> EXPR [2666:21]
31224 | | | `--PLUS -> + [2666:21]
31225 | | | |--STRING_LITERAL -> "44:7: " [2666:12]
31226 | | | `--METHOD_CALL -> ( [2666:38]
31227 | | | |--IDENT -> getCheckMessage [2666:23]
31228 | | | |--ELIST -> ELIST [2666:39]
31229 | | | | |--EXPR -> EXPR [2666:39]
31230 | | | | | `--IDENT -> MSG_CHILD_ERROR [2666:39]
31231 | | | | |--COMMA -> , [2666:54]
31232 | | | | |--EXPR -> EXPR [2666:56]
31233 | | | | | `--STRING_LITERAL -> "method call" [2666:56]
31234 | | | | |--COMMA -> , [2666:69]
31235 | | | | |--EXPR -> EXPR [2666:71]
31236 | | | | | `--NUM_INT -> 6 [2666:71]
31237 | | | | |--COMMA -> , [2666:72]
31238 | | | | `--EXPR -> EXPR [2666:74]
31239 | | | | `--NUM_INT -> 8 [2666:74]
31240 | | | `--RPAREN -> ) [2666:75]
31241 | | |--COMMA -> , [2666:76]
31242 | | |--EXPR -> EXPR [2667:21]
31243 | | | `--PLUS -> + [2667:21]
31244 | | | |--STRING_LITERAL -> "45:9: " [2667:12]
31245 | | | `--METHOD_CALL -> ( [2667:38]
31246 | | | |--IDENT -> getCheckMessage [2667:23]
31247 | | | |--ELIST -> ELIST [2667:39]
31248 | | | | |--EXPR -> EXPR [2667:39]
31249 | | | | | `--IDENT -> MSG_CHILD_ERROR [2667:39]
31250 | | | | |--COMMA -> , [2667:54]
31251 | | | | |--EXPR -> EXPR [2667:56]
31252 | | | | | `--STRING_LITERAL -> "method call" [2667:56]
31253 | | | | |--COMMA -> , [2667:69]
31254 | | | | |--EXPR -> EXPR [2667:71]
31255 | | | | | `--NUM_INT -> 8 [2667:71]
31256 | | | | |--COMMA -> , [2667:72]
31257 | | | | `--EXPR -> EXPR [2667:74]
31258 | | | | `--NUM_INT -> 10 [2667:74]
31259 | | | `--RPAREN -> ) [2667:76]
31260 | | |--COMMA -> , [2667:77]
31261 | | |--EXPR -> EXPR [2668:21]
31262 | | | `--PLUS -> + [2668:21]
31263 | | | |--STRING_LITERAL -> "47:7: " [2668:12]
31264 | | | `--METHOD_CALL -> ( [2668:38]
31265 | | | |--IDENT -> getCheckMessage [2668:23]
31266 | | | |--ELIST -> ELIST [2668:39]
31267 | | | | |--EXPR -> EXPR [2668:39]
31268 | | | | | `--IDENT -> MSG_ERROR [2668:39]
31269 | | | | |--COMMA -> , [2668:48]
31270 | | | | |--EXPR -> EXPR [2668:50]
31271 | | | | | `--STRING_LITERAL -> "method call rparen" [2668:50]
31272 | | | | |--COMMA -> , [2668:70]
31273 | | | | |--EXPR -> EXPR [2668:72]
31274 | | | | | `--NUM_INT -> 6 [2668:72]
31275 | | | | |--COMMA -> , [2668:73]
31276 | | | | `--EXPR -> EXPR [2668:75]
31277 | | | | `--NUM_INT -> 8 [2668:75]
31278 | | | `--RPAREN -> ) [2668:76]
31279 | | |--COMMA -> , [2668:77]
31280 | | |--EXPR -> EXPR [2669:21]
31281 | | | `--PLUS -> + [2669:21]
31282 | | | |--STRING_LITERAL -> "61:6: " [2669:12]
31283 | | | `--METHOD_CALL -> ( [2669:38]
31284 | | | |--IDENT -> getCheckMessage [2669:23]
31285 | | | |--ELIST -> ELIST [2669:39]
31286 | | | | |--EXPR -> EXPR [2669:39]
31287 | | | | | `--IDENT -> MSG_ERROR [2669:39]
31288 | | | | |--COMMA -> , [2669:48]
31289 | | | | |--EXPR -> EXPR [2669:50]
31290 | | | | | `--STRING_LITERAL -> "foo" [2669:50]
31291 | | | | |--COMMA -> , [2669:55]
31292 | | | | |--EXPR -> EXPR [2669:57]
31293 | | | | | `--NUM_INT -> 5 [2669:57]
31294 | | | | |--COMMA -> , [2669:58]
31295 | | | | `--EXPR -> EXPR [2669:60]
31296 | | | | `--NUM_INT -> 8 [2669:60]
31297 | | | `--RPAREN -> ) [2669:61]
31298 | | |--COMMA -> , [2669:62]
31299 | | |--EXPR -> EXPR [2670:21]
31300 | | | `--PLUS -> + [2670:21]
31301 | | | |--STRING_LITERAL -> "82:5: " [2670:12]
31302 | | | `--METHOD_CALL -> ( [2670:38]
31303 | | | |--IDENT -> getCheckMessage [2670:23]
31304 | | | |--ELIST -> ELIST [2670:39]
31305 | | | | |--EXPR -> EXPR [2670:39]
31306 | | | | | `--IDENT -> MSG_ERROR [2670:39]
31307 | | | | |--COMMA -> , [2670:48]
31308 | | | | |--EXPR -> EXPR [2670:50]
31309 | | | | | `--STRING_LITERAL -> "if rcurly" [2670:50]
31310 | | | | |--COMMA -> , [2670:61]
31311 | | | | |--EXPR -> EXPR [2670:63]
31312 | | | | | `--NUM_INT -> 4 [2670:63]
31313 | | | | |--COMMA -> , [2670:64]
31314 | | | | `--EXPR -> EXPR [2670:66]
31315 | | | | `--NUM_INT -> 6 [2670:66]
31316 | | | `--RPAREN -> ) [2670:67]
31317 | | |--COMMA -> , [2670:68]
31318 | | |--EXPR -> EXPR [2671:21]
31319 | | | `--PLUS -> + [2671:21]
31320 | | | |--STRING_LITERAL -> "84:3: " [2671:12]
31321 | | | `--METHOD_CALL -> ( [2671:38]
31322 | | | |--IDENT -> getCheckMessage [2671:23]
31323 | | | |--ELIST -> ELIST [2671:39]
31324 | | | | |--EXPR -> EXPR [2671:39]
31325 | | | | | `--IDENT -> MSG_CHILD_ERROR [2671:39]
31326 | | | | |--COMMA -> , [2671:54]
31327 | | | | |--EXPR -> EXPR [2671:56]
31328 | | | | | `--STRING_LITERAL -> "method def" [2671:56]
31329 | | | | |--COMMA -> , [2671:68]
31330 | | | | |--EXPR -> EXPR [2671:70]
31331 | | | | | `--NUM_INT -> 2 [2671:70]
31332 | | | | |--COMMA -> , [2671:71]
31333 | | | | `--EXPR -> EXPR [2671:73]
31334 | | | | `--NUM_INT -> 4 [2671:73]
31335 | | | `--RPAREN -> ) [2671:74]
31336 | | |--COMMA -> , [2671:75]
31337 | | `--RCURLY -> } [2672:8]
31338 | |--SEMI -> ; [2672:9]
31339 | |--VARIABLE_DEF -> VARIABLE_DEF [2673:8]
31340 | | |--MODIFIERS -> MODIFIERS [2673:8]
31341 | | | `--FINAL -> final [2673:8]
31342 | | |--TYPE -> TYPE [2673:14]
31343 | | | `--IDENT -> String [2673:14]
31344 | | |--IDENT -> fileName [2673:21]
31345 | | `--ASSIGN -> = [2673:30]
31346 | | `--EXPR -> EXPR [2673:32]
31347 | | `--STRING_LITERAL -> "InputIndentationChainedMethodWithBracketOnNewLine.java" [2673:32]
31348 | |--SEMI -> ; [2673:88]
31349 | |--EXPR -> EXPR [2674:19]
31350 | | `--METHOD_CALL -> ( [2674:19]
31351 | | |--IDENT -> verifyWarns [2674:8]
31352 | | |--ELIST -> ELIST [2674:20]
31353 | | | |--EXPR -> EXPR [2674:20]
31354 | | | | `--IDENT -> checkConfig [2674:20]
31355 | | | |--COMMA -> , [2674:31]
31356 | | | |--EXPR -> EXPR [2674:40]
31357 | | | | `--METHOD_CALL -> ( [2674:40]
31358 | | | | |--IDENT -> getPath [2674:33]
31359 | | | | |--ELIST -> ELIST [2674:41]
31360 | | | | | `--EXPR -> EXPR [2674:41]
31361 | | | | | `--IDENT -> fileName [2674:41]
31362 | | | | `--RPAREN -> ) [2674:49]
31363 | | | |--COMMA -> , [2674:50]
31364 | | | `--EXPR -> EXPR [2674:52]
31365 | | | `--IDENT -> expected [2674:52]
31366 | | `--RPAREN -> ) [2674:60]
31367 | |--SEMI -> ; [2674:61]
31368 | `--RCURLY -> } [2675:4]
31369 |--METHOD_DEF -> METHOD_DEF [2677:4]
31370 | |--MODIFIERS -> MODIFIERS [2677:4]
31371 | | |--ANNOTATION -> ANNOTATION [2677:4]
31372 | | | |--AT -> @ [2677:4]
31373 | | | `--IDENT -> Test [2677:5]
31374 | | `--LITERAL_PUBLIC -> public [2678:4]
31375 | |--TYPE -> TYPE [2678:11]
31376 | | `--LITERAL_VOID -> void [2678:11]
31377 | |--IDENT -> testIndentationSwitchExpression [2678:16]
31378 | |--LPAREN -> ( [2678:47]
31379 | |--PARAMETERS -> PARAMETERS [2678:48]
31380 | |--RPAREN -> ) [2678:48]
31381 | |--LITERAL_THROWS -> throws [2678:50]
31382 | | `--IDENT -> Exception [2678:57]
31383 | `--SLIST -> { [2678:67]
31384 | |--VARIABLE_DEF -> VARIABLE_DEF [2679:8]
31385 | | |--MODIFIERS -> MODIFIERS [2679:8]
31386 | | | `--FINAL -> final [2679:8]
31387 | | |--TYPE -> TYPE [2679:14]
31388 | | | `--IDENT -> DefaultConfiguration [2679:14]
31389 | | |--IDENT -> checkConfig [2679:35]
31390 | | `--ASSIGN -> = [2679:47]
31391 | | `--EXPR -> EXPR [2679:67]
31392 | | `--METHOD_CALL -> ( [2679:67]
31393 | | |--IDENT -> createModuleConfig [2679:49]
31394 | | |--ELIST -> ELIST [2679:84]
31395 | | | `--EXPR -> EXPR [2679:84]
31396 | | | `--DOT -> . [2679:84]
31397 | | | |--IDENT -> IndentationCheck [2679:68]
31398 | | | `--LITERAL_CLASS -> class [2679:85]
31399 | | `--RPAREN -> ) [2679:90]
31400 | |--SEMI -> ; [2679:91]
31401 | |--EXPR -> EXPR [2680:32]
31402 | | `--METHOD_CALL -> ( [2680:32]
31403 | | |--DOT -> . [2680:19]
31404 | | | |--IDENT -> checkConfig [2680:8]
31405 | | | `--IDENT -> addAttribute [2680:20]
31406 | | |--ELIST -> ELIST [2680:33]
31407 | | | |--EXPR -> EXPR [2680:33]
31408 | | | | `--STRING_LITERAL -> "tabWidth" [2680:33]
31409 | | | |--COMMA -> , [2680:43]
31410 | | | `--EXPR -> EXPR [2680:45]
31411 | | | `--STRING_LITERAL -> "4" [2680:45]
31412 | | `--RPAREN -> ) [2680:48]
31413 | |--SEMI -> ; [2680:49]
31414 | |--VARIABLE_DEF -> VARIABLE_DEF [2681:8]
31415 | | |--MODIFIERS -> MODIFIERS [2681:8]
31416 | | | `--FINAL -> final [2681:8]
31417 | | |--TYPE -> TYPE [2681:20]
31418 | | | `--ARRAY_DECLARATOR -> [ [2681:20]
31419 | | | |--IDENT -> String [2681:14]
31420 | | | `--RBRACK -> ] [2681:21]
31421 | | |--IDENT -> expected [2681:23]
31422 | | `--ASSIGN -> = [2681:32]
31423 | | `--ARRAY_INIT -> { [2681:34]
31424 | | |--EXPR -> EXPR [2682:21]
31425 | | | `--PLUS -> + [2682:21]
31426 | | | |--STRING_LITERAL -> "17:1: " [2682:12]
31427 | | | `--METHOD_CALL -> ( [2682:38]
31428 | | | |--IDENT -> getCheckMessage [2682:23]
31429 | | | |--ELIST -> ELIST [2682:39]
31430 | | | | |--EXPR -> EXPR [2682:39]
31431 | | | | | `--IDENT -> MSG_CHILD_ERROR [2682:39]
31432 | | | | |--COMMA -> , [2682:54]
31433 | | | | |--EXPR -> EXPR [2682:56]
31434 | | | | | `--STRING_LITERAL -> "case" [2682:56]
31435 | | | | |--COMMA -> , [2682:62]
31436 | | | | |--EXPR -> EXPR [2682:64]
31437 | | | | | `--NUM_INT -> 0 [2682:64]
31438 | | | | |--COMMA -> , [2682:65]
31439 | | | | `--EXPR -> EXPR [2682:67]
31440 | | | | `--NUM_INT -> 12 [2682:67]
31441 | | | `--RPAREN -> ) [2682:69]
31442 | | |--COMMA -> , [2682:70]
31443 | | |--EXPR -> EXPR [2683:21]
31444 | | | `--PLUS -> + [2683:21]
31445 | | | |--STRING_LITERAL -> "18:9: " [2683:12]
31446 | | | `--METHOD_CALL -> ( [2683:38]
31447 | | | |--IDENT -> getCheckMessage [2683:23]
31448 | | | |--ELIST -> ELIST [2683:39]
31449 | | | | |--EXPR -> EXPR [2683:39]
31450 | | | | | `--IDENT -> MSG_CHILD_ERROR [2683:39]
31451 | | | | |--COMMA -> , [2683:54]
31452 | | | | |--EXPR -> EXPR [2683:56]
31453 | | | | | `--STRING_LITERAL -> "block" [2683:56]
31454 | | | | |--COMMA -> , [2683:63]
31455 | | | | |--EXPR -> EXPR [2683:65]
31456 | | | | | `--NUM_INT -> 8 [2683:65]
31457 | | | | |--COMMA -> , [2683:66]
31458 | | | | `--EXPR -> EXPR [2683:68]
31459 | | | | `--NUM_INT -> 16 [2683:68]
31460 | | | `--RPAREN -> ) [2683:70]
31461 | | |--COMMA -> , [2683:71]
31462 | | |--EXPR -> EXPR [2684:22]
31463 | | | `--PLUS -> + [2684:22]
31464 | | | |--STRING_LITERAL -> "21:25: " [2684:12]
31465 | | | `--METHOD_CALL -> ( [2684:39]
31466 | | | |--IDENT -> getCheckMessage [2684:24]
31467 | | | |--ELIST -> ELIST [2684:40]
31468 | | | | |--EXPR -> EXPR [2684:40]
31469 | | | | | `--IDENT -> MSG_CHILD_ERROR [2684:40]
31470 | | | | |--COMMA -> , [2684:55]
31471 | | | | |--EXPR -> EXPR [2684:57]
31472 | | | | | `--STRING_LITERAL -> "case" [2684:57]
31473 | | | | |--COMMA -> , [2684:63]
31474 | | | | |--EXPR -> EXPR [2684:65]
31475 | | | | | `--NUM_INT -> 24 [2684:65]
31476 | | | | |--COMMA -> , [2684:67]
31477 | | | | `--EXPR -> EXPR [2684:69]
31478 | | | | `--NUM_INT -> 12 [2684:69]
31479 | | | `--RPAREN -> ) [2684:71]
31480 | | |--COMMA -> , [2684:72]
31481 | | |--EXPR -> EXPR [2685:21]
31482 | | | `--PLUS -> + [2685:21]
31483 | | | |--STRING_LITERAL -> "22:9: " [2685:12]
31484 | | | `--METHOD_CALL -> ( [2685:38]
31485 | | | |--IDENT -> getCheckMessage [2685:23]
31486 | | | |--ELIST -> ELIST [2685:39]
31487 | | | | |--EXPR -> EXPR [2685:39]
31488 | | | | | `--IDENT -> MSG_CHILD_ERROR [2685:39]
31489 | | | | |--COMMA -> , [2685:54]
31490 | | | | |--EXPR -> EXPR [2685:56]
31491 | | | | | `--STRING_LITERAL -> "block" [2685:56]
31492 | | | | |--COMMA -> , [2685:63]
31493 | | | | |--EXPR -> EXPR [2685:65]
31494 | | | | | `--NUM_INT -> 8 [2685:65]
31495 | | | | |--COMMA -> , [2685:66]
31496 | | | | `--EXPR -> EXPR [2685:68]
31497 | | | | `--NUM_INT -> 16 [2685:68]
31498 | | | `--RPAREN -> ) [2685:70]
31499 | | |--COMMA -> , [2685:71]
31500 | | |--EXPR -> EXPR [2686:21]
31501 | | | `--PLUS -> + [2686:21]
31502 | | | |--STRING_LITERAL -> "27:9: " [2686:12]
31503 | | | `--METHOD_CALL -> ( [2686:38]
31504 | | | |--IDENT -> getCheckMessage [2686:23]
31505 | | | |--ELIST -> ELIST [2686:39]
31506 | | | | |--EXPR -> EXPR [2686:39]
31507 | | | | | `--IDENT -> MSG_CHILD_ERROR [2686:39]
31508 | | | | |--COMMA -> , [2686:54]
31509 | | | | |--EXPR -> EXPR [2686:56]
31510 | | | | | `--STRING_LITERAL -> "block" [2686:56]
31511 | | | | |--COMMA -> , [2686:63]
31512 | | | | |--EXPR -> EXPR [2686:65]
31513 | | | | | `--NUM_INT -> 8 [2686:65]
31514 | | | | |--COMMA -> , [2686:66]
31515 | | | | `--EXPR -> EXPR [2686:68]
31516 | | | | `--NUM_INT -> 20 [2686:68]
31517 | | | `--RPAREN -> ) [2686:70]
31518 | | |--COMMA -> , [2686:71]
31519 | | |--EXPR -> EXPR [2687:21]
31520 | | | `--PLUS -> + [2687:21]
31521 | | | |--STRING_LITERAL -> "29:1: " [2687:12]
31522 | | | `--METHOD_CALL -> ( [2687:38]
31523 | | | |--IDENT -> getCheckMessage [2687:23]
31524 | | | |--ELIST -> ELIST [2687:39]
31525 | | | | |--EXPR -> EXPR [2687:39]
31526 | | | | | `--IDENT -> MSG_CHILD_ERROR [2687:39]
31527 | | | | |--COMMA -> , [2687:54]
31528 | | | | |--EXPR -> EXPR [2687:56]
31529 | | | | | `--STRING_LITERAL -> "block" [2687:56]
31530 | | | | |--COMMA -> , [2687:63]
31531 | | | | |--EXPR -> EXPR [2687:65]
31532 | | | | | `--NUM_INT -> 0 [2687:65]
31533 | | | | |--COMMA -> , [2687:66]
31534 | | | | `--EXPR -> EXPR [2687:68]
31535 | | | | `--NUM_INT -> 16 [2687:68]
31536 | | | `--RPAREN -> ) [2687:70]
31537 | | |--COMMA -> , [2687:71]
31538 | | |--EXPR -> EXPR [2688:21]
31539 | | | `--PLUS -> + [2688:21]
31540 | | | |--STRING_LITERAL -> "30:1: " [2688:12]
31541 | | | `--METHOD_CALL -> ( [2688:38]
31542 | | | |--IDENT -> getCheckMessage [2688:23]
31543 | | | |--ELIST -> ELIST [2688:39]
31544 | | | | |--EXPR -> EXPR [2688:39]
31545 | | | | | `--IDENT -> MSG_ERROR [2688:39]
31546 | | | | |--COMMA -> , [2688:48]
31547 | | | | |--EXPR -> EXPR [2688:50]
31548 | | | | | `--STRING_LITERAL -> "yield" [2688:50]
31549 | | | | |--COMMA -> , [2688:57]
31550 | | | | |--EXPR -> EXPR [2688:59]
31551 | | | | | `--NUM_INT -> 0 [2688:59]
31552 | | | | |--COMMA -> , [2688:60]
31553 | | | | `--EXPR -> EXPR [2688:62]
31554 | | | | `--NUM_INT -> 16 [2688:62]
31555 | | | `--RPAREN -> ) [2688:64]
31556 | | |--COMMA -> , [2688:65]
31557 | | |--EXPR -> EXPR [2689:21]
31558 | | | `--PLUS -> + [2689:21]
31559 | | | |--STRING_LITERAL -> "34:5: " [2689:12]
31560 | | | `--METHOD_CALL -> ( [2689:38]
31561 | | | |--IDENT -> getCheckMessage [2689:23]
31562 | | | |--ELIST -> ELIST [2689:39]
31563 | | | | |--EXPR -> EXPR [2689:39]
31564 | | | | | `--IDENT -> MSG_CHILD_ERROR [2689:39]
31565 | | | | |--COMMA -> , [2689:54]
31566 | | | | |--EXPR -> EXPR [2689:56]
31567 | | | | | `--STRING_LITERAL -> "block" [2689:56]
31568 | | | | |--COMMA -> , [2689:63]
31569 | | | | |--EXPR -> EXPR [2689:65]
31570 | | | | | `--NUM_INT -> 4 [2689:65]
31571 | | | | |--COMMA -> , [2689:66]
31572 | | | | `--EXPR -> EXPR [2689:68]
31573 | | | | `--NUM_INT -> 20 [2689:68]
31574 | | | `--RPAREN -> ) [2689:70]
31575 | | |--COMMA -> , [2689:71]
31576 | | |--EXPR -> EXPR [2690:21]
31577 | | | `--PLUS -> + [2690:21]
31578 | | | |--STRING_LITERAL -> "44:1: " [2690:12]
31579 | | | `--METHOD_CALL -> ( [2690:38]
31580 | | | |--IDENT -> getCheckMessage [2690:23]
31581 | | | |--ELIST -> ELIST [2690:39]
31582 | | | | |--EXPR -> EXPR [2690:39]
31583 | | | | | `--IDENT -> MSG_CHILD_ERROR [2690:39]
31584 | | | | |--COMMA -> , [2690:54]
31585 | | | | |--EXPR -> EXPR [2690:56]
31586 | | | | | `--STRING_LITERAL -> "block" [2690:56]
31587 | | | | |--COMMA -> , [2690:63]
31588 | | | | |--EXPR -> EXPR [2690:65]
31589 | | | | | `--NUM_INT -> 0 [2690:65]
31590 | | | | |--COMMA -> , [2690:66]
31591 | | | | `--EXPR -> EXPR [2690:68]
31592 | | | | `--NUM_INT -> 16 [2690:68]
31593 | | | `--RPAREN -> ) [2690:70]
31594 | | |--COMMA -> , [2690:71]
31595 | | |--EXPR -> EXPR [2691:22]
31596 | | | `--PLUS -> + [2691:22]
31597 | | | |--STRING_LITERAL -> "46:21: " [2691:12]
31598 | | | `--METHOD_CALL -> ( [2691:39]
31599 | | | |--IDENT -> getCheckMessage [2691:24]
31600 | | | |--ELIST -> ELIST [2691:40]
31601 | | | | |--EXPR -> EXPR [2691:40]
31602 | | | | | `--IDENT -> MSG_CHILD_ERROR [2691:40]
31603 | | | | |--COMMA -> , [2691:55]
31604 | | | | |--EXPR -> EXPR [2691:57]
31605 | | | | | `--STRING_LITERAL -> "case" [2691:57]
31606 | | | | |--COMMA -> , [2691:63]
31607 | | | | |--EXPR -> EXPR [2691:65]
31608 | | | | | `--NUM_INT -> 20 [2691:65]
31609 | | | | |--COMMA -> , [2691:67]
31610 | | | | `--EXPR -> EXPR [2691:69]
31611 | | | | `--NUM_INT -> 12 [2691:69]
31612 | | | `--RPAREN -> ) [2691:71]
31613 | | |--COMMA -> , [2691:72]
31614 | | |--EXPR -> EXPR [2692:21]
31615 | | | `--PLUS -> + [2692:21]
31616 | | | |--STRING_LITERAL -> "47:1: " [2692:12]
31617 | | | `--METHOD_CALL -> ( [2692:38]
31618 | | | |--IDENT -> getCheckMessage [2692:23]
31619 | | | |--ELIST -> ELIST [2692:39]
31620 | | | | |--EXPR -> EXPR [2692:39]
31621 | | | | | `--IDENT -> MSG_CHILD_ERROR [2692:39]
31622 | | | | |--COMMA -> , [2692:54]
31623 | | | | |--EXPR -> EXPR [2692:56]
31624 | | | | | `--STRING_LITERAL -> "block" [2692:56]
31625 | | | | |--COMMA -> , [2692:63]
31626 | | | | |--EXPR -> EXPR [2692:65]
31627 | | | | | `--NUM_INT -> 0 [2692:65]
31628 | | | | |--COMMA -> , [2692:66]
31629 | | | | `--EXPR -> EXPR [2692:68]
31630 | | | | `--NUM_INT -> 16 [2692:68]
31631 | | | `--RPAREN -> ) [2692:70]
31632 | | |--COMMA -> , [2692:71]
31633 | | |--EXPR -> EXPR [2693:21]
31634 | | | `--PLUS -> + [2693:21]
31635 | | | |--STRING_LITERAL -> "51:9: " [2693:12]
31636 | | | `--METHOD_CALL -> ( [2693:38]
31637 | | | |--IDENT -> getCheckMessage [2693:23]
31638 | | | |--ELIST -> ELIST [2693:39]
31639 | | | | |--EXPR -> EXPR [2693:39]
31640 | | | | | `--IDENT -> MSG_CHILD_ERROR [2693:39]
31641 | | | | |--COMMA -> , [2693:54]
31642 | | | | |--EXPR -> EXPR [2693:56]
31643 | | | | | `--STRING_LITERAL -> "block" [2693:56]
31644 | | | | |--COMMA -> , [2693:63]
31645 | | | | |--EXPR -> EXPR [2693:65]
31646 | | | | | `--NUM_INT -> 8 [2693:65]
31647 | | | | |--COMMA -> , [2693:66]
31648 | | | | `--EXPR -> EXPR [2693:68]
31649 | | | | `--NUM_INT -> 20 [2693:68]
31650 | | | `--RPAREN -> ) [2693:70]
31651 | | |--COMMA -> , [2693:71]
31652 | | |--EXPR -> EXPR [2694:22]
31653 | | | `--PLUS -> + [2694:22]
31654 | | | |--STRING_LITERAL -> "56:33: " [2694:12]
31655 | | | `--METHOD_CALL -> ( [2694:39]
31656 | | | |--IDENT -> getCheckMessage [2694:24]
31657 | | | |--ELIST -> ELIST [2694:40]
31658 | | | | |--EXPR -> EXPR [2694:40]
31659 | | | | | `--IDENT -> MSG_CHILD_ERROR [2694:40]
31660 | | | | |--COMMA -> , [2694:55]
31661 | | | | |--EXPR -> EXPR [2694:57]
31662 | | | | | `--STRING_LITERAL -> "block" [2694:57]
31663 | | | | |--COMMA -> , [2694:64]
31664 | | | | |--EXPR -> EXPR [2694:66]
31665 | | | | | `--NUM_INT -> 32 [2694:66]
31666 | | | | |--COMMA -> , [2694:68]
31667 | | | | `--EXPR -> EXPR [2694:70]
31668 | | | | `--NUM_INT -> 20 [2694:70]
31669 | | | `--RPAREN -> ) [2694:72]
31670 | | |--COMMA -> , [2694:73]
31671 | | `--RCURLY -> } [2695:8]
31672 | |--SEMI -> ; [2695:9]
31673 | |--EXPR -> EXPR [2697:19]
31674 | | `--METHOD_CALL -> ( [2697:19]
31675 | | |--IDENT -> verifyWarns [2697:8]
31676 | | |--ELIST -> ELIST [2697:20]
31677 | | | |--EXPR -> EXPR [2697:20]
31678 | | | | `--IDENT -> checkConfig [2697:20]
31679 | | | |--COMMA -> , [2697:31]
31680 | | | |--EXPR -> EXPR [2698:36]
31681 | | | | `--METHOD_CALL -> ( [2698:36]
31682 | | | | |--IDENT -> getNonCompilablePath [2698:16]
31683 | | | | |--ELIST -> ELIST [2698:37]
31684 | | | | | `--EXPR -> EXPR [2698:37]
31685 | | | | | `--STRING_LITERAL -> "InputIndentationCheckSwitchExpression.java" [2698:37]
31686 | | | | `--RPAREN -> ) [2698:81]
31687 | | | |--COMMA -> , [2698:82]
31688 | | | `--EXPR -> EXPR [2699:16]
31689 | | | `--IDENT -> expected [2699:16]
31690 | | `--RPAREN -> ) [2699:24]
31691 | |--SEMI -> ; [2699:25]
31692 | `--RCURLY -> } [2700:4]
31693 |--METHOD_DEF -> METHOD_DEF [2702:4]
31694 | |--MODIFIERS -> MODIFIERS [2702:4]
31695 | | |--ANNOTATION -> ANNOTATION [2702:4]
31696 | | | |--AT -> @ [2702:4]
31697 | | | `--IDENT -> Test [2702:5]
31698 | | `--LITERAL_PUBLIC -> public [2703:4]
31699 | |--TYPE -> TYPE [2703:11]
31700 | | `--LITERAL_VOID -> void [2703:11]
31701 | |--IDENT -> testIndentationYieldStatement [2703:16]
31702 | |--LPAREN -> ( [2703:45]
31703 | |--PARAMETERS -> PARAMETERS [2703:46]
31704 | |--RPAREN -> ) [2703:46]
31705 | |--LITERAL_THROWS -> throws [2703:48]
31706 | | `--IDENT -> Exception [2703:55]
31707 | `--SLIST -> { [2703:65]
31708 | |--VARIABLE_DEF -> VARIABLE_DEF [2704:8]
31709 | | |--MODIFIERS -> MODIFIERS [2704:8]
31710 | | | `--FINAL -> final [2704:8]
31711 | | |--TYPE -> TYPE [2704:14]
31712 | | | `--IDENT -> DefaultConfiguration [2704:14]
31713 | | |--IDENT -> checkConfig [2704:35]
31714 | | `--ASSIGN -> = [2704:47]
31715 | | `--EXPR -> EXPR [2704:67]
31716 | | `--METHOD_CALL -> ( [2704:67]
31717 | | |--IDENT -> createModuleConfig [2704:49]
31718 | | |--ELIST -> ELIST [2704:84]
31719 | | | `--EXPR -> EXPR [2704:84]
31720 | | | `--DOT -> . [2704:84]
31721 | | | |--IDENT -> IndentationCheck [2704:68]
31722 | | | `--LITERAL_CLASS -> class [2704:85]
31723 | | `--RPAREN -> ) [2704:90]
31724 | |--SEMI -> ; [2704:91]
31725 | |--EXPR -> EXPR [2705:32]
31726 | | `--METHOD_CALL -> ( [2705:32]
31727 | | |--DOT -> . [2705:19]
31728 | | | |--IDENT -> checkConfig [2705:8]
31729 | | | `--IDENT -> addAttribute [2705:20]
31730 | | |--ELIST -> ELIST [2705:33]
31731 | | | |--EXPR -> EXPR [2705:33]
31732 | | | | `--STRING_LITERAL -> "tabWidth" [2705:33]
31733 | | | |--COMMA -> , [2705:43]
31734 | | | `--EXPR -> EXPR [2705:45]
31735 | | | `--STRING_LITERAL -> "4" [2705:45]
31736 | | `--RPAREN -> ) [2705:48]
31737 | |--SEMI -> ; [2705:49]
31738 | |--VARIABLE_DEF -> VARIABLE_DEF [2706:8]
31739 | | |--MODIFIERS -> MODIFIERS [2706:8]
31740 | | | `--FINAL -> final [2706:8]
31741 | | |--TYPE -> TYPE [2706:20]
31742 | | | `--ARRAY_DECLARATOR -> [ [2706:20]
31743 | | | |--IDENT -> String [2706:14]
31744 | | | `--RBRACK -> ] [2706:21]
31745 | | |--IDENT -> expected [2706:23]
31746 | | `--ASSIGN -> = [2706:32]
31747 | | `--ARRAY_INIT -> { [2706:34]
31748 | | |--EXPR -> EXPR [2707:22]
31749 | | | `--PLUS -> + [2707:22]
31750 | | | |--STRING_LITERAL -> "23:13: " [2707:12]
31751 | | | `--METHOD_CALL -> ( [2707:39]
31752 | | | |--IDENT -> getCheckMessage [2707:24]
31753 | | | |--ELIST -> ELIST [2707:40]
31754 | | | | |--EXPR -> EXPR [2707:40]
31755 | | | | | `--IDENT -> MSG_ERROR [2707:40]
31756 | | | | |--COMMA -> , [2707:49]
31757 | | | | |--EXPR -> EXPR [2707:51]
31758 | | | | | `--STRING_LITERAL -> "yield" [2707:51]
31759 | | | | |--COMMA -> , [2707:58]
31760 | | | | |--EXPR -> EXPR [2707:60]
31761 | | | | | `--NUM_INT -> 12 [2707:60]
31762 | | | | |--COMMA -> , [2707:62]
31763 | | | | `--EXPR -> EXPR [2707:64]
31764 | | | | `--NUM_INT -> 16 [2707:64]
31765 | | | `--RPAREN -> ) [2707:66]
31766 | | |--COMMA -> , [2707:67]
31767 | | |--EXPR -> EXPR [2708:21]
31768 | | | `--PLUS -> + [2708:21]
31769 | | | |--STRING_LITERAL -> "28:9: " [2708:12]
31770 | | | `--METHOD_CALL -> ( [2708:38]
31771 | | | |--IDENT -> getCheckMessage [2708:23]
31772 | | | |--ELIST -> ELIST [2708:39]
31773 | | | | |--EXPR -> EXPR [2708:39]
31774 | | | | | `--IDENT -> MSG_CHILD_ERROR [2708:39]
31775 | | | | |--COMMA -> , [2708:54]
31776 | | | | |--EXPR -> EXPR [2708:56]
31777 | | | | | `--STRING_LITERAL -> "yield" [2708:56]
31778 | | | | |--COMMA -> , [2708:63]
31779 | | | | |--EXPR -> EXPR [2708:65]
31780 | | | | | `--NUM_INT -> 8 [2708:65]
31781 | | | | |--COMMA -> , [2708:66]
31782 | | | | `--EXPR -> EXPR [2708:68]
31783 | | | | `--NUM_INT -> 16 [2708:68]
31784 | | | `--RPAREN -> ) [2708:70]
31785 | | |--COMMA -> , [2708:71]
31786 | | |--EXPR -> EXPR [2709:21]
31787 | | | `--PLUS -> + [2709:21]
31788 | | | |--STRING_LITERAL -> "40:5: " [2709:12]
31789 | | | `--METHOD_CALL -> ( [2709:38]
31790 | | | |--IDENT -> getCheckMessage [2709:23]
31791 | | | |--ELIST -> ELIST [2709:39]
31792 | | | | |--EXPR -> EXPR [2709:39]
31793 | | | | | `--IDENT -> MSG_ERROR [2709:39]
31794 | | | | |--COMMA -> , [2709:48]
31795 | | | | |--EXPR -> EXPR [2709:50]
31796 | | | | | `--STRING_LITERAL -> "yield" [2709:50]
31797 | | | | |--COMMA -> , [2709:57]
31798 | | | | |--EXPR -> EXPR [2709:59]
31799 | | | | | `--NUM_INT -> 4 [2709:59]
31800 | | | | |--COMMA -> , [2709:60]
31801 | | | | `--EXPR -> EXPR [2709:62]
31802 | | | | `--NUM_INT -> 16 [2709:62]
31803 | | | `--RPAREN -> ) [2709:64]
31804 | | |--COMMA -> , [2709:65]
31805 | | |--EXPR -> EXPR [2710:21]
31806 | | | `--PLUS -> + [2710:21]
31807 | | | |--STRING_LITERAL -> "41:9: " [2710:12]
31808 | | | `--METHOD_CALL -> ( [2710:38]
31809 | | | |--IDENT -> getCheckMessage [2710:23]
31810 | | | |--ELIST -> ELIST [2710:39]
31811 | | | | |--EXPR -> EXPR [2710:39]
31812 | | | | | `--IDENT -> MSG_CHILD_ERROR [2710:39]
31813 | | | | |--COMMA -> , [2710:54]
31814 | | | | |--EXPR -> EXPR [2710:56]
31815 | | | | | `--STRING_LITERAL -> "yield" [2710:56]
31816 | | | | |--COMMA -> , [2710:63]
31817 | | | | |--EXPR -> EXPR [2710:65]
31818 | | | | | `--NUM_INT -> 8 [2710:65]
31819 | | | | |--COMMA -> , [2710:66]
31820 | | | | `--EXPR -> EXPR [2710:68]
31821 | | | | `--NUM_INT -> 16 [2710:68]
31822 | | | `--RPAREN -> ) [2710:70]
31823 | | |--COMMA -> , [2710:71]
31824 | | |--EXPR -> EXPR [2711:21]
31825 | | | `--PLUS -> + [2711:21]
31826 | | | |--STRING_LITERAL -> "71:1: " [2711:12]
31827 | | | `--METHOD_CALL -> ( [2711:38]
31828 | | | |--IDENT -> getCheckMessage [2711:23]
31829 | | | |--ELIST -> ELIST [2711:39]
31830 | | | | |--EXPR -> EXPR [2711:39]
31831 | | | | | `--IDENT -> MSG_ERROR [2711:39]
31832 | | | | |--COMMA -> , [2711:48]
31833 | | | | |--EXPR -> EXPR [2711:50]
31834 | | | | | `--STRING_LITERAL -> "yield" [2711:50]
31835 | | | | |--COMMA -> , [2711:57]
31836 | | | | |--EXPR -> EXPR [2711:59]
31837 | | | | | `--NUM_INT -> 0 [2711:59]
31838 | | | | |--COMMA -> , [2711:60]
31839 | | | | `--EXPR -> EXPR [2711:62]
31840 | | | | `--NUM_INT -> 16 [2711:62]
31841 | | | `--RPAREN -> ) [2711:64]
31842 | | |--COMMA -> , [2711:65]
31843 | | |--EXPR -> EXPR [2712:22]
31844 | | | `--PLUS -> + [2712:22]
31845 | | | |--STRING_LITERAL -> "74:37: " [2712:12]
31846 | | | `--METHOD_CALL -> ( [2712:39]
31847 | | | |--IDENT -> getCheckMessage [2712:24]
31848 | | | |--ELIST -> ELIST [2712:40]
31849 | | | | |--EXPR -> EXPR [2712:40]
31850 | | | | | `--IDENT -> MSG_ERROR [2712:40]
31851 | | | | |--COMMA -> , [2712:49]
31852 | | | | |--EXPR -> EXPR [2712:51]
31853 | | | | | `--STRING_LITERAL -> "yield" [2712:51]
31854 | | | | |--COMMA -> , [2712:58]
31855 | | | | |--EXPR -> EXPR [2712:60]
31856 | | | | | `--NUM_INT -> 36 [2712:60]
31857 | | | | |--COMMA -> , [2712:62]
31858 | | | | `--EXPR -> EXPR [2712:64]
31859 | | | | `--NUM_INT -> 16 [2712:64]
31860 | | | `--RPAREN -> ) [2712:66]
31861 | | |--COMMA -> , [2712:67]
31862 | | `--RCURLY -> } [2713:8]
31863 | |--SEMI -> ; [2713:9]
31864 | |--EXPR -> EXPR [2715:19]
31865 | | `--METHOD_CALL -> ( [2715:19]
31866 | | |--IDENT -> verifyWarns [2715:8]
31867 | | |--ELIST -> ELIST [2715:20]
31868 | | | |--EXPR -> EXPR [2715:20]
31869 | | | | `--IDENT -> checkConfig [2715:20]
31870 | | | |--COMMA -> , [2715:31]
31871 | | | |--EXPR -> EXPR [2716:32]
31872 | | | | `--METHOD_CALL -> ( [2716:32]
31873 | | | | |--IDENT -> getNonCompilablePath [2716:12]
31874 | | | | |--ELIST -> ELIST [2716:33]
31875 | | | | | `--EXPR -> EXPR [2716:33]
31876 | | | | | `--STRING_LITERAL -> "InputIndentationYieldStatement.java" [2716:33]
31877 | | | | `--RPAREN -> ) [2716:70]
31878 | | | |--COMMA -> , [2716:71]
31879 | | | `--EXPR -> EXPR [2717:12]
31880 | | | `--IDENT -> expected [2717:12]
31881 | | `--RPAREN -> ) [2717:20]
31882 | |--SEMI -> ; [2717:21]
31883 | `--RCURLY -> } [2718:4]
31884 |--METHOD_DEF -> METHOD_DEF [2720:4]
31885 | |--MODIFIERS -> MODIFIERS [2720:4]
31886 | | |--ANNOTATION -> ANNOTATION [2720:4]
31887 | | | |--AT -> @ [2720:4]
31888 | | | `--IDENT -> Test [2720:5]
31889 | | `--LITERAL_PUBLIC -> public [2721:4]
31890 | |--TYPE -> TYPE [2721:11]
31891 | | `--LITERAL_VOID -> void [2721:11]
31892 | |--IDENT -> testIndentationSwitchExpressionCorrect [2721:16]
31893 | |--LPAREN -> ( [2721:54]
31894 | |--PARAMETERS -> PARAMETERS [2721:55]
31895 | |--RPAREN -> ) [2721:55]
31896 | |--LITERAL_THROWS -> throws [2721:57]
31897 | | `--IDENT -> Exception [2721:64]
31898 | `--SLIST -> { [2721:74]
31899 | |--VARIABLE_DEF -> VARIABLE_DEF [2722:8]
31900 | | |--MODIFIERS -> MODIFIERS [2722:8]
31901 | | | `--FINAL -> final [2722:8]
31902 | | |--TYPE -> TYPE [2722:14]
31903 | | | `--IDENT -> DefaultConfiguration [2722:14]
31904 | | |--IDENT -> checkConfig [2722:35]
31905 | | `--ASSIGN -> = [2722:47]
31906 | | `--EXPR -> EXPR [2722:67]
31907 | | `--METHOD_CALL -> ( [2722:67]
31908 | | |--IDENT -> createModuleConfig [2722:49]
31909 | | |--ELIST -> ELIST [2722:84]
31910 | | | `--EXPR -> EXPR [2722:84]
31911 | | | `--DOT -> . [2722:84]
31912 | | | |--IDENT -> IndentationCheck [2722:68]
31913 | | | `--LITERAL_CLASS -> class [2722:85]
31914 | | `--RPAREN -> ) [2722:90]
31915 | |--SEMI -> ; [2722:91]
31916 | |--EXPR -> EXPR [2723:32]
31917 | | `--METHOD_CALL -> ( [2723:32]
31918 | | |--DOT -> . [2723:19]
31919 | | | |--IDENT -> checkConfig [2723:8]
31920 | | | `--IDENT -> addAttribute [2723:20]
31921 | | |--ELIST -> ELIST [2723:33]
31922 | | | |--EXPR -> EXPR [2723:33]
31923 | | | | `--STRING_LITERAL -> "tabWidth" [2723:33]
31924 | | | |--COMMA -> , [2723:43]
31925 | | | `--EXPR -> EXPR [2723:45]
31926 | | | `--STRING_LITERAL -> "4" [2723:45]
31927 | | `--RPAREN -> ) [2723:48]
31928 | |--SEMI -> ; [2723:49]
31929 | |--VARIABLE_DEF -> VARIABLE_DEF [2724:8]
31930 | | |--MODIFIERS -> MODIFIERS [2724:8]
31931 | | | `--FINAL -> final [2724:8]
31932 | | |--TYPE -> TYPE [2724:20]
31933 | | | `--ARRAY_DECLARATOR -> [ [2724:20]
31934 | | | |--IDENT -> String [2724:14]
31935 | | | `--RBRACK -> ] [2724:21]
31936 | | |--IDENT -> expected [2724:23]
31937 | | `--ASSIGN -> = [2724:32]
31938 | | `--EXPR -> EXPR [2724:44]
31939 | | `--DOT -> . [2724:44]
31940 | | |--IDENT -> CommonUtil [2724:34]
31941 | | `--IDENT -> EMPTY_STRING_ARRAY [2724:45]
31942 | |--SEMI -> ; [2724:63]
31943 | |--EXPR -> EXPR [2725:19]
31944 | | `--METHOD_CALL -> ( [2725:19]
31945 | | |--IDENT -> verifyWarns [2725:8]
31946 | | |--ELIST -> ELIST [2725:20]
31947 | | | |--EXPR -> EXPR [2725:20]
31948 | | | | `--IDENT -> checkConfig [2725:20]
31949 | | | |--COMMA -> , [2725:31]
31950 | | | |--EXPR -> EXPR [2726:32]
31951 | | | | `--METHOD_CALL -> ( [2726:32]
31952 | | | | |--IDENT -> getNonCompilablePath [2726:12]
31953 | | | | |--ELIST -> ELIST [2726:33]
31954 | | | | | `--EXPR -> EXPR [2726:33]
31955 | | | | | `--STRING_LITERAL -> "InputIndentationCheckSwitchExpressionCorrect.java" [2726:33]
31956 | | | | `--RPAREN -> ) [2726:84]
31957 | | | |--COMMA -> , [2726:85]
31958 | | | `--EXPR -> EXPR [2727:12]
31959 | | | `--IDENT -> expected [2727:12]
31960 | | `--RPAREN -> ) [2727:20]
31961 | |--SEMI -> ; [2727:21]
31962 | `--RCURLY -> } [2728:4]
31963 |--METHOD_DEF -> METHOD_DEF [2730:4]
31964 | |--MODIFIERS -> MODIFIERS [2730:4]
31965 | | |--ANNOTATION -> ANNOTATION [2730:4]
31966 | | | |--AT -> @ [2730:4]
31967 | | | `--IDENT -> Test [2730:5]
31968 | | `--LITERAL_PUBLIC -> public [2731:4]
31969 | |--TYPE -> TYPE [2731:11]
31970 | | `--LITERAL_VOID -> void [2731:11]
31971 | |--IDENT -> testIndentationRecords [2731:16]
31972 | |--LPAREN -> ( [2731:38]
31973 | |--PARAMETERS -> PARAMETERS [2731:39]
31974 | |--RPAREN -> ) [2731:39]
31975 | |--LITERAL_THROWS -> throws [2731:41]
31976 | | `--IDENT -> Exception [2731:48]
31977 | `--SLIST -> { [2731:58]
31978 | |--VARIABLE_DEF -> VARIABLE_DEF [2732:8]
31979 | | |--MODIFIERS -> MODIFIERS [2732:8]
31980 | | | `--FINAL -> final [2732:8]
31981 | | |--TYPE -> TYPE [2732:14]
31982 | | | `--IDENT -> DefaultConfiguration [2732:14]
31983 | | |--IDENT -> checkConfig [2732:35]
31984 | | `--ASSIGN -> = [2732:47]
31985 | | `--EXPR -> EXPR [2732:67]
31986 | | `--METHOD_CALL -> ( [2732:67]
31987 | | |--IDENT -> createModuleConfig [2732:49]
31988 | | |--ELIST -> ELIST [2732:84]
31989 | | | `--EXPR -> EXPR [2732:84]
31990 | | | `--DOT -> . [2732:84]
31991 | | | |--IDENT -> IndentationCheck [2732:68]
31992 | | | `--LITERAL_CLASS -> class [2732:85]
31993 | | `--RPAREN -> ) [2732:90]
31994 | |--SEMI -> ; [2732:91]
31995 | |--EXPR -> EXPR [2733:32]
31996 | | `--METHOD_CALL -> ( [2733:32]
31997 | | |--DOT -> . [2733:19]
31998 | | | |--IDENT -> checkConfig [2733:8]
31999 | | | `--IDENT -> addAttribute [2733:20]
32000 | | |--ELIST -> ELIST [2733:33]
32001 | | | |--EXPR -> EXPR [2733:33]
32002 | | | | `--STRING_LITERAL -> "tabWidth" [2733:33]
32003 | | | |--COMMA -> , [2733:43]
32004 | | | `--EXPR -> EXPR [2733:45]
32005 | | | `--STRING_LITERAL -> "4" [2733:45]
32006 | | `--RPAREN -> ) [2733:48]
32007 | |--SEMI -> ; [2733:49]
32008 | |--EXPR -> EXPR [2734:32]
32009 | | `--METHOD_CALL -> ( [2734:32]
32010 | | |--DOT -> . [2734:19]
32011 | | | |--IDENT -> checkConfig [2734:8]
32012 | | | `--IDENT -> addAttribute [2734:20]
32013 | | |--ELIST -> ELIST [2734:33]
32014 | | | |--EXPR -> EXPR [2734:33]
32015 | | | | `--STRING_LITERAL -> "basicOffset" [2734:33]
32016 | | | |--COMMA -> , [2734:46]
32017 | | | `--EXPR -> EXPR [2734:48]
32018 | | | `--STRING_LITERAL -> "4" [2734:48]
32019 | | `--RPAREN -> ) [2734:51]
32020 | |--SEMI -> ; [2734:52]
32021 | |--EXPR -> EXPR [2735:32]
32022 | | `--METHOD_CALL -> ( [2735:32]
32023 | | |--DOT -> . [2735:19]
32024 | | | |--IDENT -> checkConfig [2735:8]
32025 | | | `--IDENT -> addAttribute [2735:20]
32026 | | |--ELIST -> ELIST [2735:33]
32027 | | | |--EXPR -> EXPR [2735:33]
32028 | | | | `--STRING_LITERAL -> "braceAdjustment" [2735:33]
32029 | | | |--COMMA -> , [2735:50]
32030 | | | `--EXPR -> EXPR [2735:52]
32031 | | | `--STRING_LITERAL -> "0" [2735:52]
32032 | | `--RPAREN -> ) [2735:55]
32033 | |--SEMI -> ; [2735:56]
32034 | |--EXPR -> EXPR [2736:32]
32035 | | `--METHOD_CALL -> ( [2736:32]
32036 | | |--DOT -> . [2736:19]
32037 | | | |--IDENT -> checkConfig [2736:8]
32038 | | | `--IDENT -> addAttribute [2736:20]
32039 | | |--ELIST -> ELIST [2736:33]
32040 | | | |--EXPR -> EXPR [2736:33]
32041 | | | | `--STRING_LITERAL -> "caseIndent" [2736:33]
32042 | | | |--COMMA -> , [2736:45]
32043 | | | `--EXPR -> EXPR [2736:47]
32044 | | | `--STRING_LITERAL -> "4" [2736:47]
32045 | | `--RPAREN -> ) [2736:50]
32046 | |--SEMI -> ; [2736:51]
32047 | |--EXPR -> EXPR [2737:32]
32048 | | `--METHOD_CALL -> ( [2737:32]
32049 | | |--DOT -> . [2737:19]
32050 | | | |--IDENT -> checkConfig [2737:8]
32051 | | | `--IDENT -> addAttribute [2737:20]
32052 | | |--ELIST -> ELIST [2737:33]
32053 | | | |--EXPR -> EXPR [2737:33]
32054 | | | | `--STRING_LITERAL -> "throwsIndent" [2737:33]
32055 | | | |--COMMA -> , [2737:47]
32056 | | | `--EXPR -> EXPR [2737:49]
32057 | | | `--STRING_LITERAL -> "4" [2737:49]
32058 | | `--RPAREN -> ) [2737:52]
32059 | |--SEMI -> ; [2737:53]
32060 | |--EXPR -> EXPR [2738:32]
32061 | | `--METHOD_CALL -> ( [2738:32]
32062 | | |--DOT -> . [2738:19]
32063 | | | |--IDENT -> checkConfig [2738:8]
32064 | | | `--IDENT -> addAttribute [2738:20]
32065 | | |--ELIST -> ELIST [2738:33]
32066 | | | |--EXPR -> EXPR [2738:33]
32067 | | | | `--STRING_LITERAL -> "arrayInitIndent" [2738:33]
32068 | | | |--COMMA -> , [2738:50]
32069 | | | `--EXPR -> EXPR [2738:52]
32070 | | | `--STRING_LITERAL -> "4" [2738:52]
32071 | | `--RPAREN -> ) [2738:55]
32072 | |--SEMI -> ; [2738:56]
32073 | |--EXPR -> EXPR [2739:32]
32074 | | `--METHOD_CALL -> ( [2739:32]
32075 | | |--DOT -> . [2739:19]
32076 | | | |--IDENT -> checkConfig [2739:8]
32077 | | | `--IDENT -> addAttribute [2739:20]
32078 | | |--ELIST -> ELIST [2739:33]
32079 | | | |--EXPR -> EXPR [2739:33]
32080 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2739:33]
32081 | | | |--COMMA -> , [2739:58]
32082 | | | `--EXPR -> EXPR [2739:60]
32083 | | | `--STRING_LITERAL -> "4" [2739:60]
32084 | | `--RPAREN -> ) [2739:63]
32085 | |--SEMI -> ; [2739:64]
32086 | |--EXPR -> EXPR [2740:32]
32087 | | `--METHOD_CALL -> ( [2740:32]
32088 | | |--DOT -> . [2740:19]
32089 | | | |--IDENT -> checkConfig [2740:8]
32090 | | | `--IDENT -> addAttribute [2740:20]
32091 | | |--ELIST -> ELIST [2740:33]
32092 | | | |--EXPR -> EXPR [2740:33]
32093 | | | | `--STRING_LITERAL -> "forceStrictCondition" [2740:33]
32094 | | | |--COMMA -> , [2740:55]
32095 | | | `--EXPR -> EXPR [2740:57]
32096 | | | `--STRING_LITERAL -> "false" [2740:57]
32097 | | `--RPAREN -> ) [2740:64]
32098 | |--SEMI -> ; [2740:65]
32099 | |--VARIABLE_DEF -> VARIABLE_DEF [2742:8]
32100 | | |--MODIFIERS -> MODIFIERS [2742:8]
32101 | | | `--FINAL -> final [2742:8]
32102 | | |--TYPE -> TYPE [2742:20]
32103 | | | `--ARRAY_DECLARATOR -> [ [2742:20]
32104 | | | |--IDENT -> String [2742:14]
32105 | | | `--RBRACK -> ] [2742:21]
32106 | | |--IDENT -> expected [2742:23]
32107 | | `--ASSIGN -> = [2742:32]
32108 | | `--EXPR -> EXPR [2742:44]
32109 | | `--DOT -> . [2742:44]
32110 | | |--IDENT -> CommonUtil [2742:34]
32111 | | `--IDENT -> EMPTY_STRING_ARRAY [2742:45]
32112 | |--SEMI -> ; [2742:63]
32113 | |--EXPR -> EXPR [2744:19]
32114 | | `--METHOD_CALL -> ( [2744:19]
32115 | | |--IDENT -> verifyWarns [2744:8]
32116 | | |--ELIST -> ELIST [2744:20]
32117 | | | |--EXPR -> EXPR [2744:20]
32118 | | | | `--IDENT -> checkConfig [2744:20]
32119 | | | |--COMMA -> , [2744:31]
32120 | | | |--EXPR -> EXPR [2745:32]
32121 | | | | `--METHOD_CALL -> ( [2745:32]
32122 | | | | |--IDENT -> getNonCompilablePath [2745:12]
32123 | | | | |--ELIST -> ELIST [2745:33]
32124 | | | | | `--EXPR -> EXPR [2745:33]
32125 | | | | | `--STRING_LITERAL -> "InputIndentationRecords.java" [2745:33]
32126 | | | | `--RPAREN -> ) [2745:63]
32127 | | | |--COMMA -> , [2745:64]
32128 | | | `--EXPR -> EXPR [2746:12]
32129 | | | `--IDENT -> expected [2746:12]
32130 | | `--RPAREN -> ) [2746:20]
32131 | |--SEMI -> ; [2746:21]
32132 | `--RCURLY -> } [2747:4]
32133 |--METHOD_DEF -> METHOD_DEF [2749:4]
32134 | |--MODIFIERS -> MODIFIERS [2749:4]
32135 | | |--ANNOTATION -> ANNOTATION [2749:4]
32136 | | | |--AT -> @ [2749:4]
32137 | | | `--IDENT -> Test [2749:5]
32138 | | `--LITERAL_PUBLIC -> public [2750:4]
32139 | |--TYPE -> TYPE [2750:11]
32140 | | `--LITERAL_VOID -> void [2750:11]
32141 | |--IDENT -> testIndentationRecordsAndCompactCtors [2750:16]
32142 | |--LPAREN -> ( [2750:53]
32143 | |--PARAMETERS -> PARAMETERS [2750:54]
32144 | |--RPAREN -> ) [2750:54]
32145 | |--LITERAL_THROWS -> throws [2750:56]
32146 | | `--IDENT -> Exception [2750:63]
32147 | `--SLIST -> { [2750:73]
32148 | |--VARIABLE_DEF -> VARIABLE_DEF [2751:8]
32149 | | |--MODIFIERS -> MODIFIERS [2751:8]
32150 | | | `--FINAL -> final [2751:8]
32151 | | |--TYPE -> TYPE [2751:14]
32152 | | | `--IDENT -> DefaultConfiguration [2751:14]
32153 | | |--IDENT -> checkConfig [2751:35]
32154 | | `--ASSIGN -> = [2751:47]
32155 | | `--EXPR -> EXPR [2751:67]
32156 | | `--METHOD_CALL -> ( [2751:67]
32157 | | |--IDENT -> createModuleConfig [2751:49]
32158 | | |--ELIST -> ELIST [2751:84]
32159 | | | `--EXPR -> EXPR [2751:84]
32160 | | | `--DOT -> . [2751:84]
32161 | | | |--IDENT -> IndentationCheck [2751:68]
32162 | | | `--LITERAL_CLASS -> class [2751:85]
32163 | | `--RPAREN -> ) [2751:90]
32164 | |--SEMI -> ; [2751:91]
32165 | |--EXPR -> EXPR [2752:32]
32166 | | `--METHOD_CALL -> ( [2752:32]
32167 | | |--DOT -> . [2752:19]
32168 | | | |--IDENT -> checkConfig [2752:8]
32169 | | | `--IDENT -> addAttribute [2752:20]
32170 | | |--ELIST -> ELIST [2752:33]
32171 | | | |--EXPR -> EXPR [2752:33]
32172 | | | | `--STRING_LITERAL -> "tabWidth" [2752:33]
32173 | | | |--COMMA -> , [2752:43]
32174 | | | `--EXPR -> EXPR [2752:45]
32175 | | | `--STRING_LITERAL -> "4" [2752:45]
32176 | | `--RPAREN -> ) [2752:48]
32177 | |--SEMI -> ; [2752:49]
32178 | |--VARIABLE_DEF -> VARIABLE_DEF [2753:8]
32179 | | |--MODIFIERS -> MODIFIERS [2753:8]
32180 | | | `--FINAL -> final [2753:8]
32181 | | |--TYPE -> TYPE [2753:20]
32182 | | | `--ARRAY_DECLARATOR -> [ [2753:20]
32183 | | | |--IDENT -> String [2753:14]
32184 | | | `--RBRACK -> ] [2753:21]
32185 | | |--IDENT -> expected [2753:23]
32186 | | `--ASSIGN -> = [2753:32]
32187 | | `--ARRAY_INIT -> { [2753:34]
32188 | | |--EXPR -> EXPR [2754:21]
32189 | | | `--PLUS -> + [2754:21]
32190 | | | |--STRING_LITERAL -> "13:1: " [2754:12]
32191 | | | `--METHOD_CALL -> ( [2754:38]
32192 | | | |--IDENT -> getCheckMessage [2754:23]
32193 | | | |--ELIST -> ELIST [2754:39]
32194 | | | | |--EXPR -> EXPR [2754:39]
32195 | | | | | `--IDENT -> MSG_ERROR [2754:39]
32196 | | | | |--COMMA -> , [2754:48]
32197 | | | | |--EXPR -> EXPR [2754:50]
32198 | | | | | `--STRING_LITERAL -> "(" [2754:50]
32199 | | | | |--COMMA -> , [2754:53]
32200 | | | | |--EXPR -> EXPR [2754:55]
32201 | | | | | `--NUM_INT -> 0 [2754:55]
32202 | | | | |--COMMA -> , [2754:56]
32203 | | | | `--EXPR -> EXPR [2754:58]
32204 | | | | `--NUM_INT -> 8 [2754:58]
32205 | | | `--RPAREN -> ) [2754:59]
32206 | | |--COMMA -> , [2754:60]
32207 | | |--EXPR -> EXPR [2755:21]
32208 | | | `--PLUS -> + [2755:21]
32209 | | | |--STRING_LITERAL -> "25:1: " [2755:12]
32210 | | | `--METHOD_CALL -> ( [2755:38]
32211 | | | |--IDENT -> getCheckMessage [2755:23]
32212 | | | |--ELIST -> ELIST [2755:39]
32213 | | | | |--EXPR -> EXPR [2755:39]
32214 | | | | | `--IDENT -> MSG_ERROR [2755:39]
32215 | | | | |--COMMA -> , [2755:48]
32216 | | | | |--EXPR -> EXPR [2755:50]
32217 | | | | | `--STRING_LITERAL -> "String" [2755:50]
32218 | | | | |--COMMA -> , [2755:58]
32219 | | | | |--EXPR -> EXPR [2755:60]
32220 | | | | | `--NUM_INT -> 0 [2755:60]
32221 | | | | |--COMMA -> , [2755:61]
32222 | | | | `--EXPR -> EXPR [2755:63]
32223 | | | | `--NUM_INT -> 12 [2755:63]
32224 | | | `--RPAREN -> ) [2755:65]
32225 | | |--COMMA -> , [2755:66]
32226 | | |--EXPR -> EXPR [2756:21]
32227 | | | `--PLUS -> + [2756:21]
32228 | | | |--STRING_LITERAL -> "38:1: " [2756:12]
32229 | | | `--METHOD_CALL -> ( [2756:38]
32230 | | | |--IDENT -> getCheckMessage [2756:23]
32231 | | | |--ELIST -> ELIST [2756:39]
32232 | | | | |--EXPR -> EXPR [2756:39]
32233 | | | | | `--IDENT -> MSG_CHILD_ERROR [2756:39]
32234 | | | | |--COMMA -> , [2756:54]
32235 | | | | |--EXPR -> EXPR [2756:56]
32236 | | | | | `--STRING_LITERAL -> "compact ctor def" [2756:56]
32237 | | | | |--COMMA -> , [2756:74]
32238 | | | | |--EXPR -> EXPR [2756:76]
32239 | | | | | `--NUM_INT -> 0 [2756:76]
32240 | | | | |--COMMA -> , [2756:77]
32241 | | | | `--EXPR -> EXPR [2756:79]
32242 | | | | `--NUM_INT -> 12 [2756:79]
32243 | | | `--RPAREN -> ) [2756:81]
32244 | | |--COMMA -> , [2756:82]
32245 | | |--EXPR -> EXPR [2757:21]
32246 | | | `--PLUS -> + [2757:21]
32247 | | | |--STRING_LITERAL -> "48:8: " [2757:12]
32248 | | | `--METHOD_CALL -> ( [2757:38]
32249 | | | |--IDENT -> getCheckMessage [2757:23]
32250 | | | |--ELIST -> ELIST [2757:39]
32251 | | | | |--EXPR -> EXPR [2757:39]
32252 | | | | | `--IDENT -> MSG_ERROR [2757:39]
32253 | | | | |--COMMA -> , [2757:48]
32254 | | | | |--EXPR -> EXPR [2757:50]
32255 | | | | | `--STRING_LITERAL -> "record def ident" [2757:50]
32256 | | | | |--COMMA -> , [2757:68]
32257 | | | | |--EXPR -> EXPR [2757:70]
32258 | | | | | `--NUM_INT -> 0 [2757:70]
32259 | | | | |--COMMA -> , [2757:71]
32260 | | | | `--EXPR -> EXPR [2757:73]
32261 | | | | `--NUM_INT -> 4 [2757:73]
32262 | | | `--RPAREN -> ) [2757:74]
32263 | | |--COMMA -> , [2757:75]
32264 | | |--EXPR -> EXPR [2758:21]
32265 | | | `--PLUS -> + [2758:21]
32266 | | | |--STRING_LITERAL -> "53:1: " [2758:12]
32267 | | | `--METHOD_CALL -> ( [2758:38]
32268 | | | |--IDENT -> getCheckMessage [2758:23]
32269 | | | |--ELIST -> ELIST [2758:39]
32270 | | | | |--EXPR -> EXPR [2758:39]
32271 | | | | | `--IDENT -> MSG_ERROR [2758:39]
32272 | | | | |--COMMA -> , [2758:48]
32273 | | | | |--EXPR -> EXPR [2758:50]
32274 | | | | | `--STRING_LITERAL -> "compact ctor def rcurly" [2758:50]
32275 | | | | |--COMMA -> , [2758:75]
32276 | | | | |--EXPR -> EXPR [2758:77]
32277 | | | | | `--NUM_INT -> 0 [2758:77]
32278 | | | | |--COMMA -> , [2758:78]
32279 | | | | `--EXPR -> EXPR [2758:80]
32280 | | | | `--NUM_INT -> 8 [2758:80]
32281 | | | `--RPAREN -> ) [2758:81]
32282 | | |--COMMA -> , [2758:82]
32283 | | |--EXPR -> EXPR [2759:21]
32284 | | | `--PLUS -> + [2759:21]
32285 | | | |--STRING_LITERAL -> "61:1: " [2759:12]
32286 | | | `--METHOD_CALL -> ( [2759:38]
32287 | | | |--IDENT -> getCheckMessage [2759:23]
32288 | | | |--ELIST -> ELIST [2759:39]
32289 | | | | |--EXPR -> EXPR [2759:39]
32290 | | | | | `--IDENT -> MSG_ERROR [2759:39]
32291 | | | | |--COMMA -> , [2759:48]
32292 | | | | |--EXPR -> EXPR [2759:50]
32293 | | | | | `--STRING_LITERAL -> "ctor def rcurly" [2759:50]
32294 | | | | |--COMMA -> , [2759:67]
32295 | | | | |--EXPR -> EXPR [2759:69]
32296 | | | | | `--NUM_INT -> 0 [2759:69]
32297 | | | | |--COMMA -> , [2759:70]
32298 | | | | `--EXPR -> EXPR [2759:72]
32299 | | | | `--NUM_INT -> 8 [2759:72]
32300 | | | `--RPAREN -> ) [2759:73]
32301 | | |--COMMA -> , [2759:74]
32302 | | `--RCURLY -> } [2760:8]
32303 | |--SEMI -> ; [2760:9]
32304 | |--EXPR -> EXPR [2762:19]
32305 | | `--METHOD_CALL -> ( [2762:19]
32306 | | |--IDENT -> verifyWarns [2762:8]
32307 | | |--ELIST -> ELIST [2762:20]
32308 | | | |--EXPR -> EXPR [2762:20]
32309 | | | | `--IDENT -> checkConfig [2762:20]
32310 | | | |--COMMA -> , [2762:31]
32311 | | | |--EXPR -> EXPR [2763:32]
32312 | | | | `--METHOD_CALL -> ( [2763:32]
32313 | | | | |--IDENT -> getNonCompilablePath [2763:12]
32314 | | | | |--ELIST -> ELIST [2763:33]
32315 | | | | | `--EXPR -> EXPR [2763:33]
32316 | | | | | `--STRING_LITERAL -> "InputIndentationRecordsAndCompactCtors.java" [2763:33]
32317 | | | | `--RPAREN -> ) [2763:78]
32318 | | | |--COMMA -> , [2763:79]
32319 | | | `--EXPR -> EXPR [2764:12]
32320 | | | `--IDENT -> expected [2764:12]
32321 | | `--RPAREN -> ) [2764:20]
32322 | |--SEMI -> ; [2764:21]
32323 | `--RCURLY -> } [2765:4]
32324 |--METHOD_DEF -> METHOD_DEF [2767:4]
32325 | |--MODIFIERS -> MODIFIERS [2767:4]
32326 | | |--ANNOTATION -> ANNOTATION [2767:4]
32327 | | | |--AT -> @ [2767:4]
32328 | | | `--IDENT -> Test [2767:5]
32329 | | `--LITERAL_PUBLIC -> public [2768:4]
32330 | |--TYPE -> TYPE [2768:11]
32331 | | `--LITERAL_VOID -> void [2768:11]
32332 | |--IDENT -> testIndentationSwitchExpressionNewLine [2768:16]
32333 | |--LPAREN -> ( [2768:54]
32334 | |--PARAMETERS -> PARAMETERS [2768:55]
32335 | |--RPAREN -> ) [2768:55]
32336 | |--LITERAL_THROWS -> throws [2768:57]
32337 | | `--IDENT -> Exception [2768:64]
32338 | `--SLIST -> { [2768:74]
32339 | |--VARIABLE_DEF -> VARIABLE_DEF [2769:8]
32340 | | |--MODIFIERS -> MODIFIERS [2769:8]
32341 | | | `--FINAL -> final [2769:8]
32342 | | |--TYPE -> TYPE [2769:14]
32343 | | | `--IDENT -> DefaultConfiguration [2769:14]
32344 | | |--IDENT -> checkConfig [2769:35]
32345 | | `--ASSIGN -> = [2769:47]
32346 | | `--EXPR -> EXPR [2769:67]
32347 | | `--METHOD_CALL -> ( [2769:67]
32348 | | |--IDENT -> createModuleConfig [2769:49]
32349 | | |--ELIST -> ELIST [2769:84]
32350 | | | `--EXPR -> EXPR [2769:84]
32351 | | | `--DOT -> . [2769:84]
32352 | | | |--IDENT -> IndentationCheck [2769:68]
32353 | | | `--LITERAL_CLASS -> class [2769:85]
32354 | | `--RPAREN -> ) [2769:90]
32355 | |--SEMI -> ; [2769:91]
32356 | |--EXPR -> EXPR [2770:32]
32357 | | `--METHOD_CALL -> ( [2770:32]
32358 | | |--DOT -> . [2770:19]
32359 | | | |--IDENT -> checkConfig [2770:8]
32360 | | | `--IDENT -> addAttribute [2770:20]
32361 | | |--ELIST -> ELIST [2770:33]
32362 | | | |--EXPR -> EXPR [2770:33]
32363 | | | | `--STRING_LITERAL -> "tabWidth" [2770:33]
32364 | | | |--COMMA -> , [2770:43]
32365 | | | `--EXPR -> EXPR [2770:45]
32366 | | | `--STRING_LITERAL -> "4" [2770:45]
32367 | | `--RPAREN -> ) [2770:48]
32368 | |--SEMI -> ; [2770:49]
32369 | |--VARIABLE_DEF -> VARIABLE_DEF [2771:8]
32370 | | |--MODIFIERS -> MODIFIERS [2771:8]
32371 | | | `--FINAL -> final [2771:8]
32372 | | |--TYPE -> TYPE [2771:20]
32373 | | | `--ARRAY_DECLARATOR -> [ [2771:20]
32374 | | | |--IDENT -> String [2771:14]
32375 | | | `--RBRACK -> ] [2771:21]
32376 | | |--IDENT -> expected [2771:23]
32377 | | `--ASSIGN -> = [2771:32]
32378 | | `--ARRAY_INIT -> { [2771:34]
32379 | | |--EXPR -> EXPR [2772:22]
32380 | | | `--PLUS -> + [2772:22]
32381 | | | |--STRING_LITERAL -> "30:13: " [2772:12]
32382 | | | `--METHOD_CALL -> ( [2772:39]
32383 | | | |--IDENT -> getCheckMessage [2772:24]
32384 | | | |--ELIST -> ELIST [2772:40]
32385 | | | | |--EXPR -> EXPR [2772:40]
32386 | | | | | `--IDENT -> MSG_ERROR [2772:40]
32387 | | | | |--COMMA -> , [2772:49]
32388 | | | | |--EXPR -> EXPR [2772:51]
32389 | | | | | `--STRING_LITERAL -> "lambda" [2772:51]
32390 | | | | |--COMMA -> , [2772:59]
32391 | | | | |--EXPR -> EXPR [2772:61]
32392 | | | | | `--NUM_INT -> 12 [2772:61]
32393 | | | | |--COMMA -> , [2772:63]
32394 | | | | `--EXPR -> EXPR [2772:65]
32395 | | | | `--NUM_INT -> 16 [2772:65]
32396 | | | `--RPAREN -> ) [2772:67]
32397 | | |--COMMA -> , [2772:68]
32398 | | |--EXPR -> EXPR [2773:22]
32399 | | | `--PLUS -> + [2773:22]
32400 | | | |--STRING_LITERAL -> "32:13: " [2773:12]
32401 | | | `--METHOD_CALL -> ( [2773:39]
32402 | | | |--IDENT -> getCheckMessage [2773:24]
32403 | | | |--ELIST -> ELIST [2773:40]
32404 | | | | |--EXPR -> EXPR [2773:40]
32405 | | | | | `--IDENT -> MSG_ERROR [2773:40]
32406 | | | | |--COMMA -> , [2773:49]
32407 | | | | |--EXPR -> EXPR [2773:51]
32408 | | | | | `--STRING_LITERAL -> "lambda" [2773:51]
32409 | | | | |--COMMA -> , [2773:59]
32410 | | | | |--EXPR -> EXPR [2773:61]
32411 | | | | | `--NUM_INT -> 12 [2773:61]
32412 | | | | |--COMMA -> , [2773:63]
32413 | | | | `--EXPR -> EXPR [2773:65]
32414 | | | | `--NUM_INT -> 16 [2773:65]
32415 | | | `--RPAREN -> ) [2773:67]
32416 | | |--COMMA -> , [2773:68]
32417 | | `--RCURLY -> } [2774:8]
32418 | |--SEMI -> ; [2774:9]
32419 | |--EXPR -> EXPR [2776:19]
32420 | | `--METHOD_CALL -> ( [2776:19]
32421 | | |--IDENT -> verifyWarns [2776:8]
32422 | | |--ELIST -> ELIST [2776:20]
32423 | | | |--EXPR -> EXPR [2776:20]
32424 | | | | `--IDENT -> checkConfig [2776:20]
32425 | | | |--COMMA -> , [2776:31]
32426 | | | |--EXPR -> EXPR [2777:32]
32427 | | | | `--METHOD_CALL -> ( [2777:32]
32428 | | | | |--IDENT -> getNonCompilablePath [2777:12]
32429 | | | | |--ELIST -> ELIST [2777:33]
32430 | | | | | `--EXPR -> EXPR [2777:33]
32431 | | | | | `--STRING_LITERAL -> "InputIndentationCheckSwitchExpressionNewLine.java" [2777:33]
32432 | | | | `--RPAREN -> ) [2777:84]
32433 | | | |--COMMA -> , [2777:85]
32434 | | | `--EXPR -> EXPR [2778:12]
32435 | | | `--IDENT -> expected [2778:12]
32436 | | `--RPAREN -> ) [2778:20]
32437 | |--SEMI -> ; [2778:21]
32438 | `--RCURLY -> } [2779:4]
32439 |--METHOD_DEF -> METHOD_DEF [2781:4]
32440 | |--MODIFIERS -> MODIFIERS [2781:4]
32441 | | |--ANNOTATION -> ANNOTATION [2781:4]
32442 | | | |--AT -> @ [2781:4]
32443 | | | `--IDENT -> Test [2781:5]
32444 | | `--LITERAL_PUBLIC -> public [2782:4]
32445 | |--TYPE -> TYPE [2782:11]
32446 | | `--LITERAL_VOID -> void [2782:11]
32447 | |--IDENT -> testIndentationMethodParenthesisOnNewLine [2782:16]
32448 | |--LPAREN -> ( [2782:57]
32449 | |--PARAMETERS -> PARAMETERS [2782:58]
32450 | |--RPAREN -> ) [2782:58]
32451 | |--LITERAL_THROWS -> throws [2782:60]
32452 | | `--IDENT -> Exception [2782:67]
32453 | `--SLIST -> { [2782:77]
32454 | |--VARIABLE_DEF -> VARIABLE_DEF [2783:8]
32455 | | |--MODIFIERS -> MODIFIERS [2783:8]
32456 | | | `--FINAL -> final [2783:8]
32457 | | |--TYPE -> TYPE [2783:14]
32458 | | | `--IDENT -> DefaultConfiguration [2783:14]
32459 | | |--IDENT -> checkConfig [2783:35]
32460 | | `--ASSIGN -> = [2783:47]
32461 | | `--EXPR -> EXPR [2783:67]
32462 | | `--METHOD_CALL -> ( [2783:67]
32463 | | |--IDENT -> createModuleConfig [2783:49]
32464 | | |--ELIST -> ELIST [2783:84]
32465 | | | `--EXPR -> EXPR [2783:84]
32466 | | | `--DOT -> . [2783:84]
32467 | | | |--IDENT -> IndentationCheck [2783:68]
32468 | | | `--LITERAL_CLASS -> class [2783:85]
32469 | | `--RPAREN -> ) [2783:90]
32470 | |--SEMI -> ; [2783:91]
32471 | |--EXPR -> EXPR [2784:32]
32472 | | `--METHOD_CALL -> ( [2784:32]
32473 | | |--DOT -> . [2784:19]
32474 | | | |--IDENT -> checkConfig [2784:8]
32475 | | | `--IDENT -> addAttribute [2784:20]
32476 | | |--ELIST -> ELIST [2784:33]
32477 | | | |--EXPR -> EXPR [2784:33]
32478 | | | | `--STRING_LITERAL -> "tabWidth" [2784:33]
32479 | | | |--COMMA -> , [2784:43]
32480 | | | `--EXPR -> EXPR [2784:45]
32481 | | | `--STRING_LITERAL -> "4" [2784:45]
32482 | | `--RPAREN -> ) [2784:48]
32483 | |--SEMI -> ; [2784:49]
32484 | |--VARIABLE_DEF -> VARIABLE_DEF [2785:8]
32485 | | |--MODIFIERS -> MODIFIERS [2785:8]
32486 | | | `--FINAL -> final [2785:8]
32487 | | |--TYPE -> TYPE [2785:20]
32488 | | | `--ARRAY_DECLARATOR -> [ [2785:20]
32489 | | | |--IDENT -> String [2785:14]
32490 | | | `--RBRACK -> ] [2785:21]
32491 | | |--IDENT -> expected [2785:23]
32492 | | `--ASSIGN -> = [2785:32]
32493 | | `--ARRAY_INIT -> { [2785:34]
32494 | | |--EXPR -> EXPR [2786:21]
32495 | | | `--PLUS -> + [2786:21]
32496 | | | |--STRING_LITERAL -> "13:9: " [2786:12]
32497 | | | `--METHOD_CALL -> ( [2786:38]
32498 | | | |--IDENT -> getCheckMessage [2786:23]
32499 | | | |--ELIST -> ELIST [2786:39]
32500 | | | | |--EXPR -> EXPR [2786:39]
32501 | | | | | `--IDENT -> MSG_ERROR [2786:39]
32502 | | | | |--COMMA -> , [2786:48]
32503 | | | | |--EXPR -> EXPR [2786:50]
32504 | | | | | `--STRING_LITERAL -> "method def rparen" [2786:50]
32505 | | | | |--COMMA -> , [2786:69]
32506 | | | | |--EXPR -> EXPR [2786:71]
32507 | | | | | `--NUM_INT -> 8 [2786:71]
32508 | | | | |--COMMA -> , [2786:72]
32509 | | | | `--EXPR -> EXPR [2786:74]
32510 | | | | `--NUM_INT -> 4 [2786:74]
32511 | | | `--RPAREN -> ) [2786:75]
32512 | | |--COMMA -> , [2786:76]
32513 | | |--EXPR -> EXPR [2787:21]
32514 | | | `--PLUS -> + [2787:21]
32515 | | | |--STRING_LITERAL -> "18:9: " [2787:12]
32516 | | | `--METHOD_CALL -> ( [2787:38]
32517 | | | |--IDENT -> getCheckMessage [2787:23]
32518 | | | |--ELIST -> ELIST [2787:39]
32519 | | | | |--EXPR -> EXPR [2787:39]
32520 | | | | | `--IDENT -> MSG_ERROR [2787:39]
32521 | | | | |--COMMA -> , [2787:48]
32522 | | | | |--EXPR -> EXPR [2787:50]
32523 | | | | | `--STRING_LITERAL -> "method def rparen" [2787:50]
32524 | | | | |--COMMA -> , [2787:69]
32525 | | | | |--EXPR -> EXPR [2787:71]
32526 | | | | | `--NUM_INT -> 8 [2787:71]
32527 | | | | |--COMMA -> , [2787:72]
32528 | | | | `--EXPR -> EXPR [2787:74]
32529 | | | | `--NUM_INT -> 4 [2787:74]
32530 | | | `--RPAREN -> ) [2787:75]
32531 | | |--COMMA -> , [2787:76]
32532 | | `--RCURLY -> } [2788:8]
32533 | |--SEMI -> ; [2788:9]
32534 | |--EXPR -> EXPR [2790:19]
32535 | | `--METHOD_CALL -> ( [2790:19]
32536 | | |--IDENT -> verifyWarns [2790:8]
32537 | | |--ELIST -> ELIST [2790:20]
32538 | | | |--EXPR -> EXPR [2790:20]
32539 | | | | `--IDENT -> checkConfig [2790:20]
32540 | | | |--COMMA -> , [2790:31]
32541 | | | |--EXPR -> EXPR [2791:23]
32542 | | | | `--METHOD_CALL -> ( [2791:23]
32543 | | | | |--IDENT -> getPath [2791:16]
32544 | | | | |--ELIST -> ELIST [2791:24]
32545 | | | | | `--EXPR -> EXPR [2791:24]
32546 | | | | | `--STRING_LITERAL -> "InputIndentationCheckMethodParenOnNewLine.java" [2791:24]
32547 | | | | `--RPAREN -> ) [2791:72]
32548 | | | |--COMMA -> , [2791:73]
32549 | | | `--EXPR -> EXPR [2792:16]
32550 | | | `--IDENT -> expected [2792:16]
32551 | | `--RPAREN -> ) [2792:24]
32552 | |--SEMI -> ; [2792:25]
32553 | `--RCURLY -> } [2793:4]
32554 |--METHOD_DEF -> METHOD_DEF [2795:4]
32555 | |--MODIFIERS -> MODIFIERS [2795:4]
32556 | | |--ANNOTATION -> ANNOTATION [2795:4]
32557 | | | |--AT -> @ [2795:4]
32558 | | | `--IDENT -> Test [2795:5]
32559 | | `--LITERAL_PUBLIC -> public [2796:4]
32560 | |--TYPE -> TYPE [2796:11]
32561 | | `--LITERAL_VOID -> void [2796:11]
32562 | |--IDENT -> testIndentationMethodParenthesisOnNewLine1 [2796:16]
32563 | |--LPAREN -> ( [2796:58]
32564 | |--PARAMETERS -> PARAMETERS [2796:59]
32565 | |--RPAREN -> ) [2796:59]
32566 | |--LITERAL_THROWS -> throws [2796:61]
32567 | | `--IDENT -> Exception [2796:68]
32568 | `--SLIST -> { [2796:78]
32569 | |--VARIABLE_DEF -> VARIABLE_DEF [2797:8]
32570 | | |--MODIFIERS -> MODIFIERS [2797:8]
32571 | | | `--FINAL -> final [2797:8]
32572 | | |--TYPE -> TYPE [2797:14]
32573 | | | `--IDENT -> DefaultConfiguration [2797:14]
32574 | | |--IDENT -> checkConfig [2797:35]
32575 | | `--ASSIGN -> = [2797:47]
32576 | | `--EXPR -> EXPR [2797:67]
32577 | | `--METHOD_CALL -> ( [2797:67]
32578 | | |--IDENT -> createModuleConfig [2797:49]
32579 | | |--ELIST -> ELIST [2797:84]
32580 | | | `--EXPR -> EXPR [2797:84]
32581 | | | `--DOT -> . [2797:84]
32582 | | | |--IDENT -> IndentationCheck [2797:68]
32583 | | | `--LITERAL_CLASS -> class [2797:85]
32584 | | `--RPAREN -> ) [2797:90]
32585 | |--SEMI -> ; [2797:91]
32586 | |--EXPR -> EXPR [2798:32]
32587 | | `--METHOD_CALL -> ( [2798:32]
32588 | | |--DOT -> . [2798:19]
32589 | | | |--IDENT -> checkConfig [2798:8]
32590 | | | `--IDENT -> addAttribute [2798:20]
32591 | | |--ELIST -> ELIST [2798:33]
32592 | | | |--EXPR -> EXPR [2798:33]
32593 | | | | `--STRING_LITERAL -> "tabWidth" [2798:33]
32594 | | | |--COMMA -> , [2798:43]
32595 | | | `--EXPR -> EXPR [2798:45]
32596 | | | `--STRING_LITERAL -> "4" [2798:45]
32597 | | `--RPAREN -> ) [2798:48]
32598 | |--SEMI -> ; [2798:49]
32599 | |--VARIABLE_DEF -> VARIABLE_DEF [2799:8]
32600 | | |--MODIFIERS -> MODIFIERS [2799:8]
32601 | | | `--FINAL -> final [2799:8]
32602 | | |--TYPE -> TYPE [2799:20]
32603 | | | `--ARRAY_DECLARATOR -> [ [2799:20]
32604 | | | |--IDENT -> String [2799:14]
32605 | | | `--RBRACK -> ] [2799:21]
32606 | | |--IDENT -> expected [2799:23]
32607 | | `--ASSIGN -> = [2799:32]
32608 | | `--ARRAY_INIT -> { [2799:34]
32609 | | |--EXPR -> EXPR [2800:22]
32610 | | | `--PLUS -> + [2800:22]
32611 | | | |--STRING_LITERAL -> "11:10: " [2800:12]
32612 | | | `--METHOD_CALL -> ( [2800:39]
32613 | | | |--IDENT -> getCheckMessage [2800:24]
32614 | | | |--ELIST -> ELIST [2800:40]
32615 | | | | |--EXPR -> EXPR [2800:40]
32616 | | | | | `--IDENT -> MSG_ERROR [2800:40]
32617 | | | | |--COMMA -> , [2800:49]
32618 | | | | |--EXPR -> EXPR [2800:51]
32619 | | | | | `--STRING_LITERAL -> "2" [2800:51]
32620 | | | | |--COMMA -> , [2800:54]
32621 | | | | |--EXPR -> EXPR [2800:56]
32622 | | | | | `--NUM_INT -> 9 [2800:56]
32623 | | | | |--COMMA -> , [2800:57]
32624 | | | | `--EXPR -> EXPR [2800:59]
32625 | | | | `--NUM_INT -> 12 [2800:59]
32626 | | | `--RPAREN -> ) [2800:61]
32627 | | |--COMMA -> , [2800:62]
32628 | | |--EXPR -> EXPR [2801:21]
32629 | | | `--PLUS -> + [2801:21]
32630 | | | |--STRING_LITERAL -> "17:8: " [2801:12]
32631 | | | `--METHOD_CALL -> ( [2801:38]
32632 | | | |--IDENT -> getCheckMessage [2801:23]
32633 | | | |--ELIST -> ELIST [2801:39]
32634 | | | | |--EXPR -> EXPR [2801:39]
32635 | | | | | `--IDENT -> MSG_ERROR [2801:39]
32636 | | | | |--COMMA -> , [2801:48]
32637 | | | | |--EXPR -> EXPR [2801:50]
32638 | | | | | `--STRING_LITERAL -> "int" [2801:50]
32639 | | | | |--COMMA -> , [2801:55]
32640 | | | | |--EXPR -> EXPR [2801:57]
32641 | | | | | `--NUM_INT -> 7 [2801:57]
32642 | | | | |--COMMA -> , [2801:58]
32643 | | | | `--EXPR -> EXPR [2801:60]
32644 | | | | `--NUM_INT -> 8 [2801:60]
32645 | | | `--RPAREN -> ) [2801:61]
32646 | | |--COMMA -> , [2801:62]
32647 | | |--EXPR -> EXPR [2802:21]
32648 | | | `--PLUS -> + [2802:21]
32649 | | | |--STRING_LITERAL -> "18:9: " [2802:12]
32650 | | | `--METHOD_CALL -> ( [2802:38]
32651 | | | |--IDENT -> getCheckMessage [2802:23]
32652 | | | |--ELIST -> ELIST [2802:39]
32653 | | | | |--EXPR -> EXPR [2802:39]
32654 | | | | | `--IDENT -> MSG_ERROR [2802:39]
32655 | | | | |--COMMA -> , [2802:48]
32656 | | | | |--EXPR -> EXPR [2802:50]
32657 | | | | | `--STRING_LITERAL -> "method def rparen" [2802:50]
32658 | | | | |--COMMA -> , [2802:69]
32659 | | | | |--EXPR -> EXPR [2802:71]
32660 | | | | | `--NUM_INT -> 8 [2802:71]
32661 | | | | |--COMMA -> , [2802:72]
32662 | | | | `--EXPR -> EXPR [2802:74]
32663 | | | | `--NUM_INT -> 4 [2802:74]
32664 | | | `--RPAREN -> ) [2802:75]
32665 | | |--COMMA -> , [2802:76]
32666 | | `--RCURLY -> } [2803:8]
32667 | |--SEMI -> ; [2803:9]
32668 | |--EXPR -> EXPR [2805:19]
32669 | | `--METHOD_CALL -> ( [2805:19]
32670 | | |--IDENT -> verifyWarns [2805:8]
32671 | | |--ELIST -> ELIST [2805:20]
32672 | | | |--EXPR -> EXPR [2805:20]
32673 | | | | `--IDENT -> checkConfig [2805:20]
32674 | | | |--COMMA -> , [2805:31]
32675 | | | |--EXPR -> EXPR [2806:23]
32676 | | | | `--METHOD_CALL -> ( [2806:23]
32677 | | | | |--IDENT -> getPath [2806:16]
32678 | | | | |--ELIST -> ELIST [2806:24]
32679 | | | | | `--EXPR -> EXPR [2806:24]
32680 | | | | | `--STRING_LITERAL -> "InputIndentationCheckMethodParenOnNewLine1.java" [2806:24]
32681 | | | | `--RPAREN -> ) [2806:73]
32682 | | | |--COMMA -> , [2806:74]
32683 | | | `--EXPR -> EXPR [2807:16]
32684 | | | `--IDENT -> expected [2807:16]
32685 | | `--RPAREN -> ) [2807:24]
32686 | |--SEMI -> ; [2807:25]
32687 | `--RCURLY -> } [2808:4]
32688 |--METHOD_DEF -> METHOD_DEF [2810:4]
32689 | |--MODIFIERS -> MODIFIERS [2810:4]
32690 | | |--ANNOTATION -> ANNOTATION [2810:4]
32691 | | | |--AT -> @ [2810:4]
32692 | | | `--IDENT -> Test [2810:5]
32693 | | `--LITERAL_PUBLIC -> public [2811:4]
32694 | |--TYPE -> TYPE [2811:11]
32695 | | `--LITERAL_VOID -> void [2811:11]
32696 | |--IDENT -> testIndentationLineWrappedRecordDeclaration [2811:16]
32697 | |--LPAREN -> ( [2811:59]
32698 | |--PARAMETERS -> PARAMETERS [2811:60]
32699 | |--RPAREN -> ) [2811:60]
32700 | |--LITERAL_THROWS -> throws [2811:62]
32701 | | `--IDENT -> Exception [2811:69]
32702 | `--SLIST -> { [2811:79]
32703 | |--VARIABLE_DEF -> VARIABLE_DEF [2812:8]
32704 | | |--MODIFIERS -> MODIFIERS [2812:8]
32705 | | | `--FINAL -> final [2812:8]
32706 | | |--TYPE -> TYPE [2812:14]
32707 | | | `--IDENT -> DefaultConfiguration [2812:14]
32708 | | |--IDENT -> checkConfig [2812:35]
32709 | | `--ASSIGN -> = [2812:47]
32710 | | `--EXPR -> EXPR [2812:67]
32711 | | `--METHOD_CALL -> ( [2812:67]
32712 | | |--IDENT -> createModuleConfig [2812:49]
32713 | | |--ELIST -> ELIST [2812:84]
32714 | | | `--EXPR -> EXPR [2812:84]
32715 | | | `--DOT -> . [2812:84]
32716 | | | |--IDENT -> IndentationCheck [2812:68]
32717 | | | `--LITERAL_CLASS -> class [2812:85]
32718 | | `--RPAREN -> ) [2812:90]
32719 | |--SEMI -> ; [2812:91]
32720 | |--EXPR -> EXPR [2813:32]
32721 | | `--METHOD_CALL -> ( [2813:32]
32722 | | |--DOT -> . [2813:19]
32723 | | | |--IDENT -> checkConfig [2813:8]
32724 | | | `--IDENT -> addAttribute [2813:20]
32725 | | |--ELIST -> ELIST [2813:33]
32726 | | | |--EXPR -> EXPR [2813:33]
32727 | | | | `--STRING_LITERAL -> "tabWidth" [2813:33]
32728 | | | |--COMMA -> , [2813:43]
32729 | | | `--EXPR -> EXPR [2813:45]
32730 | | | `--STRING_LITERAL -> "4" [2813:45]
32731 | | `--RPAREN -> ) [2813:48]
32732 | |--SEMI -> ; [2813:49]
32733 | |--EXPR -> EXPR [2814:32]
32734 | | `--METHOD_CALL -> ( [2814:32]
32735 | | |--DOT -> . [2814:19]
32736 | | | |--IDENT -> checkConfig [2814:8]
32737 | | | `--IDENT -> addAttribute [2814:20]
32738 | | |--ELIST -> ELIST [2814:33]
32739 | | | |--EXPR -> EXPR [2814:33]
32740 | | | | `--STRING_LITERAL -> "basicOffset" [2814:33]
32741 | | | |--COMMA -> , [2814:46]
32742 | | | `--EXPR -> EXPR [2814:48]
32743 | | | `--STRING_LITERAL -> "4" [2814:48]
32744 | | `--RPAREN -> ) [2814:51]
32745 | |--SEMI -> ; [2814:52]
32746 | |--EXPR -> EXPR [2815:32]
32747 | | `--METHOD_CALL -> ( [2815:32]
32748 | | |--DOT -> . [2815:19]
32749 | | | |--IDENT -> checkConfig [2815:8]
32750 | | | `--IDENT -> addAttribute [2815:20]
32751 | | |--ELIST -> ELIST [2815:33]
32752 | | | |--EXPR -> EXPR [2815:33]
32753 | | | | `--STRING_LITERAL -> "braceAdjustment" [2815:33]
32754 | | | |--COMMA -> , [2815:50]
32755 | | | `--EXPR -> EXPR [2815:52]
32756 | | | `--STRING_LITERAL -> "0" [2815:52]
32757 | | `--RPAREN -> ) [2815:55]
32758 | |--SEMI -> ; [2815:56]
32759 | |--EXPR -> EXPR [2816:32]
32760 | | `--METHOD_CALL -> ( [2816:32]
32761 | | |--DOT -> . [2816:19]
32762 | | | |--IDENT -> checkConfig [2816:8]
32763 | | | `--IDENT -> addAttribute [2816:20]
32764 | | |--ELIST -> ELIST [2816:33]
32765 | | | |--EXPR -> EXPR [2816:33]
32766 | | | | `--STRING_LITERAL -> "caseIndent" [2816:33]
32767 | | | |--COMMA -> , [2816:45]
32768 | | | `--EXPR -> EXPR [2816:47]
32769 | | | `--STRING_LITERAL -> "4" [2816:47]
32770 | | `--RPAREN -> ) [2816:50]
32771 | |--SEMI -> ; [2816:51]
32772 | |--EXPR -> EXPR [2817:32]
32773 | | `--METHOD_CALL -> ( [2817:32]
32774 | | |--DOT -> . [2817:19]
32775 | | | |--IDENT -> checkConfig [2817:8]
32776 | | | `--IDENT -> addAttribute [2817:20]
32777 | | |--ELIST -> ELIST [2817:33]
32778 | | | |--EXPR -> EXPR [2817:33]
32779 | | | | `--STRING_LITERAL -> "throwsIndent" [2817:33]
32780 | | | |--COMMA -> , [2817:47]
32781 | | | `--EXPR -> EXPR [2817:49]
32782 | | | `--STRING_LITERAL -> "4" [2817:49]
32783 | | `--RPAREN -> ) [2817:52]
32784 | |--SEMI -> ; [2817:53]
32785 | |--EXPR -> EXPR [2818:32]
32786 | | `--METHOD_CALL -> ( [2818:32]
32787 | | |--DOT -> . [2818:19]
32788 | | | |--IDENT -> checkConfig [2818:8]
32789 | | | `--IDENT -> addAttribute [2818:20]
32790 | | |--ELIST -> ELIST [2818:33]
32791 | | | |--EXPR -> EXPR [2818:33]
32792 | | | | `--STRING_LITERAL -> "arrayInitIndent" [2818:33]
32793 | | | |--COMMA -> , [2818:50]
32794 | | | `--EXPR -> EXPR [2818:52]
32795 | | | `--STRING_LITERAL -> "4" [2818:52]
32796 | | `--RPAREN -> ) [2818:55]
32797 | |--SEMI -> ; [2818:56]
32798 | |--EXPR -> EXPR [2819:32]
32799 | | `--METHOD_CALL -> ( [2819:32]
32800 | | |--DOT -> . [2819:19]
32801 | | | |--IDENT -> checkConfig [2819:8]
32802 | | | `--IDENT -> addAttribute [2819:20]
32803 | | |--ELIST -> ELIST [2819:33]
32804 | | | |--EXPR -> EXPR [2819:33]
32805 | | | | `--STRING_LITERAL -> "lineWrappingIndentation" [2819:33]
32806 | | | |--COMMA -> , [2819:58]
32807 | | | `--EXPR -> EXPR [2819:60]
32808 | | | `--STRING_LITERAL -> "4" [2819:60]
32809 | | `--RPAREN -> ) [2819:63]
32810 | |--SEMI -> ; [2819:64]
32811 | |--VARIABLE_DEF -> VARIABLE_DEF [2821:8]
32812 | | |--MODIFIERS -> MODIFIERS [2821:8]
32813 | | | `--FINAL -> final [2821:8]
32814 | | |--TYPE -> TYPE [2821:20]
32815 | | | `--ARRAY_DECLARATOR -> [ [2821:20]
32816 | | | |--IDENT -> String [2821:14]
32817 | | | `--RBRACK -> ] [2821:21]
32818 | | |--IDENT -> expected [2821:23]
32819 | | `--ASSIGN -> = [2821:32]
32820 | | `--ARRAY_INIT -> { [2821:34]
32821 | | |--EXPR -> EXPR [2822:21]
32822 | | | `--PLUS -> + [2822:21]
32823 | | | |--STRING_LITERAL -> "33:1: " [2822:12]
32824 | | | `--METHOD_CALL -> ( [2822:38]
32825 | | | |--IDENT -> getCheckMessage [2822:23]
32826 | | | |--ELIST -> ELIST [2822:39]
32827 | | | | |--EXPR -> EXPR [2822:39]
32828 | | | | | `--IDENT -> MSG_ERROR [2822:39]
32829 | | | | |--COMMA -> , [2822:48]
32830 | | | | |--EXPR -> EXPR [2822:50]
32831 | | | | | `--STRING_LITERAL -> ")" [2822:50]
32832 | | | | |--COMMA -> , [2822:53]
32833 | | | | |--EXPR -> EXPR [2822:55]
32834 | | | | | `--NUM_INT -> 0 [2822:55]
32835 | | | | |--COMMA -> , [2822:56]
32836 | | | | `--EXPR -> EXPR [2822:58]
32837 | | | | `--NUM_INT -> 4 [2822:58]
32838 | | | `--RPAREN -> ) [2822:59]
32839 | | |--COMMA -> , [2822:60]
32840 | | |--EXPR -> EXPR [2823:22]
32841 | | | `--PLUS -> + [2823:22]
32842 | | | |--STRING_LITERAL -> "55:11: " [2823:12]
32843 | | | `--METHOD_CALL -> ( [2823:39]
32844 | | | |--IDENT -> getCheckMessage [2823:24]
32845 | | | |--ELIST -> ELIST [2823:40]
32846 | | | | |--EXPR -> EXPR [2823:40]
32847 | | | | | `--IDENT -> MSG_ERROR [2823:40]
32848 | | | | |--COMMA -> , [2823:49]
32849 | | | | |--EXPR -> EXPR [2823:51]
32850 | | | | | `--STRING_LITERAL -> "interface def ident" [2823:51]
32851 | | | | |--COMMA -> , [2823:72]
32852 | | | | |--EXPR -> EXPR [2823:74]
32853 | | | | | `--NUM_INT -> 0 [2823:74]
32854 | | | | |--COMMA -> , [2823:75]
32855 | | | | `--EXPR -> EXPR [2823:77]
32856 | | | | `--NUM_INT -> 4 [2823:77]
32857 | | | `--RPAREN -> ) [2823:78]
32858 | | |--COMMA -> , [2823:79]
32859 | | |--EXPR -> EXPR [2824:21]
32860 | | | `--PLUS -> + [2824:21]
32861 | | | |--STRING_LITERAL -> "56:1: " [2824:12]
32862 | | | `--METHOD_CALL -> ( [2824:38]
32863 | | | |--IDENT -> getCheckMessage [2824:23]
32864 | | | |--ELIST -> ELIST [2824:39]
32865 | | | | |--EXPR -> EXPR [2824:39]
32866 | | | | | `--IDENT -> MSG_ERROR [2824:39]
32867 | | | | |--COMMA -> , [2824:48]
32868 | | | | |--EXPR -> EXPR [2824:50]
32869 | | | | | `--STRING_LITERAL -> "method def modifier" [2824:50]
32870 | | | | |--COMMA -> , [2824:71]
32871 | | | | |--EXPR -> EXPR [2824:73]
32872 | | | | | `--NUM_INT -> 0 [2824:73]
32873 | | | | |--COMMA -> , [2824:74]
32874 | | | | `--EXPR -> EXPR [2824:76]
32875 | | | | `--NUM_INT -> 8 [2824:76]
32876 | | | `--RPAREN -> ) [2824:77]
32877 | | |--COMMA -> , [2824:78]
32878 | | |--EXPR -> EXPR [2825:21]
32879 | | | `--PLUS -> + [2825:21]
32880 | | | |--STRING_LITERAL -> "57:1: " [2825:12]
32881 | | | `--METHOD_CALL -> ( [2825:38]
32882 | | | |--IDENT -> getCheckMessage [2825:23]
32883 | | | |--ELIST -> ELIST [2825:39]
32884 | | | | |--EXPR -> EXPR [2825:39]
32885 | | | | | `--IDENT -> MSG_ERROR [2825:39]
32886 | | | | |--COMMA -> , [2825:48]
32887 | | | | |--EXPR -> EXPR [2825:50]
32888 | | | | | `--STRING_LITERAL -> "void" [2825:50]
32889 | | | | |--COMMA -> , [2825:56]
32890 | | | | |--EXPR -> EXPR [2825:58]
32891 | | | | | `--NUM_INT -> 0 [2825:58]
32892 | | | | |--COMMA -> , [2825:59]
32893 | | | | `--EXPR -> EXPR [2825:61]
32894 | | | | `--NUM_INT -> 4 [2825:61]
32895 | | | `--RPAREN -> ) [2825:62]
32896 | | |--COMMA -> , [2825:63]
32897 | | |--EXPR -> EXPR [2826:21]
32898 | | | `--PLUS -> + [2826:21]
32899 | | | |--STRING_LITERAL -> "58:1: " [2826:12]
32900 | | | `--METHOD_CALL -> ( [2826:38]
32901 | | | |--IDENT -> getCheckMessage [2826:23]
32902 | | | |--ELIST -> ELIST [2826:39]
32903 | | | | |--EXPR -> EXPR [2826:39]
32904 | | | | | `--IDENT -> MSG_ERROR [2826:39]
32905 | | | | |--COMMA -> , [2826:48]
32906 | | | | |--EXPR -> EXPR [2826:50]
32907 | | | | | `--STRING_LITERAL -> "method" [2826:50]
32908 | | | | |--COMMA -> , [2826:58]
32909 | | | | |--EXPR -> EXPR [2826:60]
32910 | | | | | `--NUM_INT -> 0 [2826:60]
32911 | | | | |--COMMA -> , [2826:61]
32912 | | | | `--EXPR -> EXPR [2826:63]
32913 | | | | `--NUM_INT -> 4 [2826:63]
32914 | | | `--RPAREN -> ) [2826:64]
32915 | | |--COMMA -> , [2826:65]
32916 | | |--EXPR -> EXPR [2827:21]
32917 | | | `--PLUS -> + [2827:21]
32918 | | | |--STRING_LITERAL -> "59:1: " [2827:12]
32919 | | | `--METHOD_CALL -> ( [2827:38]
32920 | | | |--IDENT -> getCheckMessage [2827:23]
32921 | | | |--ELIST -> ELIST [2827:39]
32922 | | | | |--EXPR -> EXPR [2827:39]
32923 | | | | | `--IDENT -> MSG_ERROR [2827:39]
32924 | | | | |--COMMA -> , [2827:48]
32925 | | | | |--EXPR -> EXPR [2827:50]
32926 | | | | | `--STRING_LITERAL -> "throws" [2827:50]
32927 | | | | |--COMMA -> , [2827:58]
32928 | | | | |--EXPR -> EXPR [2827:60]
32929 | | | | | `--NUM_INT -> 0 [2827:60]
32930 | | | | |--COMMA -> , [2827:61]
32931 | | | | `--EXPR -> EXPR [2827:63]
32932 | | | | `--NUM_INT -> 4 [2827:63]
32933 | | | `--RPAREN -> ) [2827:64]
32934 | | |--COMMA -> , [2827:65]
32935 | | |--EXPR -> EXPR [2828:21]
32936 | | | `--PLUS -> + [2828:21]
32937 | | | |--STRING_LITERAL -> "60:1: " [2828:12]
32938 | | | `--METHOD_CALL -> ( [2828:38]
32939 | | | |--IDENT -> getCheckMessage [2828:23]
32940 | | | |--ELIST -> ELIST [2828:39]
32941 | | | | |--EXPR -> EXPR [2828:39]
32942 | | | | | `--IDENT -> MSG_ERROR [2828:39]
32943 | | | | |--COMMA -> , [2828:48]
32944 | | | | |--EXPR -> EXPR [2828:50]
32945 | | | | | `--STRING_LITERAL -> "IOException" [2828:50]
32946 | | | | |--COMMA -> , [2828:63]
32947 | | | | |--EXPR -> EXPR [2828:65]
32948 | | | | | `--NUM_INT -> 0 [2828:65]
32949 | | | | |--COMMA -> , [2828:66]
32950 | | | | `--EXPR -> EXPR [2828:68]
32951 | | | | `--NUM_INT -> 4 [2828:68]
32952 | | | `--RPAREN -> ) [2828:69]
32953 | | |--COMMA -> , [2828:70]
32954 | | |--EXPR -> EXPR [2829:21]
32955 | | | `--PLUS -> + [2829:21]
32956 | | | |--STRING_LITERAL -> "61:1: " [2829:12]
32957 | | | `--METHOD_CALL -> ( [2829:38]
32958 | | | |--IDENT -> getCheckMessage [2829:23]
32959 | | | |--ELIST -> ELIST [2829:39]
32960 | | | | |--EXPR -> EXPR [2829:39]
32961 | | | | | `--IDENT -> MSG_ERROR [2829:39]
32962 | | | | |--COMMA -> , [2829:48]
32963 | | | | |--EXPR -> EXPR [2829:50]
32964 | | | | | `--STRING_LITERAL -> "method def rcurly" [2829:50]
32965 | | | | |--COMMA -> , [2829:69]
32966 | | | | |--EXPR -> EXPR [2829:71]
32967 | | | | | `--NUM_INT -> 0 [2829:71]
32968 | | | | |--COMMA -> , [2829:72]
32969 | | | | `--EXPR -> EXPR [2829:74]
32970 | | | | `--NUM_INT -> 8 [2829:74]
32971 | | | `--RPAREN -> ) [2829:75]
32972 | | |--COMMA -> , [2829:76]
32973 | | |--EXPR -> EXPR [2830:21]
32974 | | | `--PLUS -> + [2830:21]
32975 | | | |--STRING_LITERAL -> "62:1: " [2830:12]
32976 | | | `--METHOD_CALL -> ( [2830:38]
32977 | | | |--IDENT -> getCheckMessage [2830:23]
32978 | | | |--ELIST -> ELIST [2830:39]
32979 | | | | |--EXPR -> EXPR [2830:39]
32980 | | | | | `--IDENT -> MSG_ERROR [2830:39]
32981 | | | | |--COMMA -> , [2830:48]
32982 | | | | |--EXPR -> EXPR [2830:50]
32983 | | | | | `--STRING_LITERAL -> "interface def rcurly" [2830:50]
32984 | | | | |--COMMA -> , [2830:72]
32985 | | | | |--EXPR -> EXPR [2830:74]
32986 | | | | | `--NUM_INT -> 0 [2830:74]
32987 | | | | |--COMMA -> , [2830:75]
32988 | | | | `--EXPR -> EXPR [2830:77]
32989 | | | | `--NUM_INT -> 4 [2830:77]
32990 | | | `--RPAREN -> ) [2830:78]
32991 | | |--COMMA -> , [2830:79]
32992 | | |--EXPR -> EXPR [2831:21]
32993 | | | `--PLUS -> + [2831:21]
32994 | | | |--STRING_LITERAL -> "75:8: " [2831:12]
32995 | | | `--METHOD_CALL -> ( [2831:38]
32996 | | | |--IDENT -> getCheckMessage [2831:23]
32997 | | | |--ELIST -> ELIST [2831:39]
32998 | | | | |--EXPR -> EXPR [2831:39]
32999 | | | | | `--IDENT -> MSG_ERROR [2831:39]
33000 | | | | |--COMMA -> , [2831:48]
33001 | | | | |--EXPR -> EXPR [2831:50]
33002 | | | | | `--STRING_LITERAL -> "record def ident" [2831:50]
33003 | | | | |--COMMA -> , [2831:68]
33004 | | | | |--EXPR -> EXPR [2831:70]
33005 | | | | | `--NUM_INT -> 0 [2831:70]
33006 | | | | |--COMMA -> , [2831:71]
33007 | | | | `--EXPR -> EXPR [2831:73]
33008 | | | | `--NUM_INT -> 4 [2831:73]
33009 | | | `--RPAREN -> ) [2831:74]
33010 | | |--COMMA -> , [2831:75]
33011 | | |--EXPR -> EXPR [2832:21]
33012 | | | `--PLUS -> + [2832:21]
33013 | | | |--STRING_LITERAL -> "76:1: " [2832:12]
33014 | | | `--METHOD_CALL -> ( [2832:38]
33015 | | | |--IDENT -> getCheckMessage [2832:23]
33016 | | | |--ELIST -> ELIST [2832:39]
33017 | | | | |--EXPR -> EXPR [2832:39]
33018 | | | | | `--IDENT -> MSG_ERROR [2832:39]
33019 | | | | |--COMMA -> , [2832:48]
33020 | | | | |--EXPR -> EXPR [2832:50]
33021 | | | | | `--STRING_LITERAL -> "record def rparen" [2832:50]
33022 | | | | |--COMMA -> , [2832:69]
33023 | | | | |--EXPR -> EXPR [2832:71]
33024 | | | | | `--NUM_INT -> 0 [2832:71]
33025 | | | | |--COMMA -> , [2832:72]
33026 | | | | `--EXPR -> EXPR [2832:74]
33027 | | | | `--NUM_INT -> 4 [2832:74]
33028 | | | `--RPAREN -> ) [2832:75]
33029 | | |--COMMA -> , [2832:76]
33030 | | |--EXPR -> EXPR [2833:21]
33031 | | | `--PLUS -> + [2833:21]
33032 | | | |--STRING_LITERAL -> "77:1: " [2833:12]
33033 | | | `--METHOD_CALL -> ( [2833:38]
33034 | | | |--IDENT -> getCheckMessage [2833:23]
33035 | | | |--ELIST -> ELIST [2833:39]
33036 | | | | |--EXPR -> EXPR [2833:39]
33037 | | | | | `--IDENT -> MSG_ERROR [2833:39]
33038 | | | | |--COMMA -> , [2833:48]
33039 | | | | |--EXPR -> EXPR [2833:50]
33040 | | | | | `--STRING_LITERAL -> "implements" [2833:50]
33041 | | | | |--COMMA -> , [2833:62]
33042 | | | | |--EXPR -> EXPR [2833:64]
33043 | | | | | `--NUM_INT -> 0 [2833:64]
33044 | | | | |--COMMA -> , [2833:65]
33045 | | | | `--EXPR -> EXPR [2833:67]
33046 | | | | `--NUM_INT -> 4 [2833:67]
33047 | | | `--RPAREN -> ) [2833:68]
33048 | | |--COMMA -> , [2833:69]
33049 | | |--EXPR -> EXPR [2834:21]
33050 | | | `--PLUS -> + [2834:21]
33051 | | | |--STRING_LITERAL -> "78:1: " [2834:12]
33052 | | | `--METHOD_CALL -> ( [2834:38]
33053 | | | |--IDENT -> getCheckMessage [2834:23]
33054 | | | |--ELIST -> ELIST [2834:39]
33055 | | | | |--EXPR -> EXPR [2834:39]
33056 | | | | | `--IDENT -> MSG_ERROR [2834:39]
33057 | | | | |--COMMA -> , [2834:48]
33058 | | | | |--EXPR -> EXPR [2834:50]
33059 | | | | | `--STRING_LITERAL -> "SimpleInterface2" [2834:50]
33060 | | | | |--COMMA -> , [2834:68]
33061 | | | | |--EXPR -> EXPR [2834:70]
33062 | | | | | `--NUM_INT -> 0 [2834:70]
33063 | | | | |--COMMA -> , [2834:71]
33064 | | | | `--EXPR -> EXPR [2834:73]
33065 | | | | `--NUM_INT -> 4 [2834:73]
33066 | | | `--RPAREN -> ) [2834:74]
33067 | | |--COMMA -> , [2834:75]
33068 | | |--EXPR -> EXPR [2835:21]
33069 | | | `--PLUS -> + [2835:21]
33070 | | | |--STRING_LITERAL -> "79:8: " [2835:12]
33071 | | | `--METHOD_CALL -> ( [2835:38]
33072 | | | |--IDENT -> getCheckMessage [2835:23]
33073 | | | |--ELIST -> ELIST [2835:39]
33074 | | | | |--EXPR -> EXPR [2835:39]
33075 | | | | | `--IDENT -> MSG_ERROR [2835:39]
33076 | | | | |--COMMA -> , [2835:48]
33077 | | | | |--EXPR -> EXPR [2835:50]
33078 | | | | | `--STRING_LITERAL -> "record def ident" [2835:50]
33079 | | | | |--COMMA -> , [2835:68]
33080 | | | | |--EXPR -> EXPR [2835:70]
33081 | | | | | `--NUM_INT -> 0 [2835:70]
33082 | | | | |--COMMA -> , [2835:71]
33083 | | | | `--EXPR -> EXPR [2835:73]
33084 | | | | `--NUM_INT -> 8 [2835:73]
33085 | | | `--RPAREN -> ) [2835:74]
33086 | | |--COMMA -> , [2835:75]
33087 | | |--EXPR -> EXPR [2836:21]
33088 | | | `--PLUS -> + [2836:21]
33089 | | | |--STRING_LITERAL -> "80:1: " [2836:12]
33090 | | | `--METHOD_CALL -> ( [2836:38]
33091 | | | |--IDENT -> getCheckMessage [2836:23]
33092 | | | |--ELIST -> ELIST [2836:39]
33093 | | | | |--EXPR -> EXPR [2836:39]
33094 | | | | | `--IDENT -> MSG_ERROR [2836:39]
33095 | | | | |--COMMA -> , [2836:48]
33096 | | | | |--EXPR -> EXPR [2836:50]
33097 | | | | | `--STRING_LITERAL -> "(" [2836:50]
33098 | | | | |--COMMA -> , [2836:53]
33099 | | | | |--EXPR -> EXPR [2836:55]
33100 | | | | | `--NUM_INT -> 0 [2836:55]
33101 | | | | |--COMMA -> , [2836:56]
33102 | | | | `--EXPR -> EXPR [2836:58]
33103 | | | | `--NUM_INT -> 4 [2836:58]
33104 | | | `--RPAREN -> ) [2836:59]
33105 | | |--COMMA -> , [2836:60]
33106 | | |--EXPR -> EXPR [2837:21]
33107 | | | `--PLUS -> + [2837:21]
33108 | | | |--STRING_LITERAL -> "81:1: " [2837:12]
33109 | | | `--METHOD_CALL -> ( [2837:38]
33110 | | | |--IDENT -> getCheckMessage [2837:23]
33111 | | | |--ELIST -> ELIST [2837:39]
33112 | | | | |--EXPR -> EXPR [2837:39]
33113 | | | | | `--IDENT -> MSG_ERROR [2837:39]
33114 | | | | |--COMMA -> , [2837:48]
33115 | | | | |--EXPR -> EXPR [2837:50]
33116 | | | | | `--STRING_LITERAL -> "record def rparen" [2837:50]
33117 | | | | |--COMMA -> , [2837:69]
33118 | | | | |--EXPR -> EXPR [2837:71]
33119 | | | | | `--NUM_INT -> 0 [2837:71]
33120 | | | | |--COMMA -> , [2837:72]
33121 | | | | `--EXPR -> EXPR [2837:74]
33122 | | | | `--NUM_INT -> 8 [2837:74]
33123 | | | `--RPAREN -> ) [2837:75]
33124 | | |--COMMA -> , [2837:76]
33125 | | |--EXPR -> EXPR [2838:21]
33126 | | | `--PLUS -> + [2838:21]
33127 | | | |--STRING_LITERAL -> "82:1: " [2838:12]
33128 | | | `--METHOD_CALL -> ( [2838:38]
33129 | | | |--IDENT -> getCheckMessage [2838:23]
33130 | | | |--ELIST -> ELIST [2838:39]
33131 | | | | |--EXPR -> EXPR [2838:39]
33132 | | | | | `--IDENT -> MSG_ERROR [2838:39]
33133 | | | | |--COMMA -> , [2838:48]
33134 | | | | |--EXPR -> EXPR [2838:50]
33135 | | | | | `--STRING_LITERAL -> "record def lcurly" [2838:50]
33136 | | | | |--COMMA -> , [2838:69]
33137 | | | | |--EXPR -> EXPR [2838:71]
33138 | | | | | `--NUM_INT -> 0 [2838:71]
33139 | | | | |--COMMA -> , [2838:72]
33140 | | | | `--EXPR -> EXPR [2838:74]
33141 | | | | `--NUM_INT -> 8 [2838:74]
33142 | | | `--RPAREN -> ) [2838:75]
33143 | | |--COMMA -> , [2838:76]
33144 | | |--EXPR -> EXPR [2839:21]
33145 | | | `--PLUS -> + [2839:21]
33146 | | | |--STRING_LITERAL -> "83:1: " [2839:12]
33147 | | | `--METHOD_CALL -> ( [2839:38]
33148 | | | |--IDENT -> getCheckMessage [2839:23]
33149 | | | |--ELIST -> ELIST [2839:39]
33150 | | | | |--EXPR -> EXPR [2839:39]
33151 | | | | | `--IDENT -> MSG_ERROR [2839:39]
33152 | | | | |--COMMA -> , [2839:48]
33153 | | | | |--EXPR -> EXPR [2839:50]
33154 | | | | | `--STRING_LITERAL -> "record def rcurly" [2839:50]
33155 | | | | |--COMMA -> , [2839:69]
33156 | | | | |--EXPR -> EXPR [2839:71]
33157 | | | | | `--NUM_INT -> 0 [2839:71]
33158 | | | | |--COMMA -> , [2839:72]
33159 | | | | `--EXPR -> EXPR [2839:74]
33160 | | | | `--NUM_INT -> 8 [2839:74]
33161 | | | `--RPAREN -> ) [2839:75]
33162 | | |--COMMA -> , [2839:76]
33163 | | |--EXPR -> EXPR [2840:21]
33164 | | | `--PLUS -> + [2840:21]
33165 | | | |--STRING_LITERAL -> "84:1: " [2840:12]
33166 | | | `--METHOD_CALL -> ( [2840:38]
33167 | | | |--IDENT -> getCheckMessage [2840:23]
33168 | | | |--ELIST -> ELIST [2840:39]
33169 | | | | |--EXPR -> EXPR [2840:39]
33170 | | | | | `--IDENT -> MSG_ERROR [2840:39]
33171 | | | | |--COMMA -> , [2840:48]
33172 | | | | |--EXPR -> EXPR [2840:50]
33173 | | | | | `--STRING_LITERAL -> "record def rcurly" [2840:50]
33174 | | | | |--COMMA -> , [2840:69]
33175 | | | | |--EXPR -> EXPR [2840:71]
33176 | | | | | `--NUM_INT -> 0 [2840:71]
33177 | | | | |--COMMA -> , [2840:72]
33178 | | | | `--EXPR -> EXPR [2840:74]
33179 | | | | `--NUM_INT -> 4 [2840:74]
33180 | | | `--RPAREN -> ) [2840:75]
33181 | | |--COMMA -> , [2840:76]
33182 | | `--RCURLY -> } [2841:8]
33183 | |--SEMI -> ; [2841:9]
33184 | |--EXPR -> EXPR [2843:19]
33185 | | `--METHOD_CALL -> ( [2843:19]
33186 | | |--IDENT -> verifyWarns [2843:8]
33187 | | |--ELIST -> ELIST [2843:20]
33188 | | | |--EXPR -> EXPR [2843:20]
33189 | | | | `--IDENT -> checkConfig [2843:20]
33190 | | | |--COMMA -> , [2843:31]
33191 | | | |--EXPR -> EXPR [2844:32]
33192 | | | | `--METHOD_CALL -> ( [2844:32]
33193 | | | | |--IDENT -> getNonCompilablePath [2844:12]
33194 | | | | |--ELIST -> ELIST [2844:33]
33195 | | | | | `--EXPR -> EXPR [2844:33]
33196 | | | | | `--STRING_LITERAL -> "InputIndentationLineWrappedRecordDeclaration.java" [2844:33]
33197 | | | | `--RPAREN -> ) [2844:84]
33198 | | | |--COMMA -> , [2844:85]
33199 | | | `--EXPR -> EXPR [2845:12]
33200 | | | `--IDENT -> expected [2845:12]
33201 | | `--RPAREN -> ) [2845:20]
33202 | |--SEMI -> ; [2845:21]
33203 | `--RCURLY -> } [2846:4]
33204 |--CLASS_DEF -> CLASS_DEF [2848:4]
33205 | |--MODIFIERS -> MODIFIERS [2848:4]
33206 | | |--LITERAL_PRIVATE -> private [2848:4]
33207 | | |--LITERAL_STATIC -> static [2848:12]
33208 | | `--FINAL -> final [2848:19]
33209 | |--LITERAL_CLASS -> class [2848:25]
33210 | |--IDENT -> IndentAudit [2848:31]
33211 | |--IMPLEMENTS_CLAUSE -> implements [2848:43]
33212 | | `--IDENT -> AuditListener [2848:54]
33213 | `--OBJBLOCK -> OBJBLOCK [2848:68]
33214 | |--LCURLY -> { [2848:68]
33215 | |--VARIABLE_DEF -> VARIABLE_DEF [2850:8]
33216 | | |--MODIFIERS -> MODIFIERS [2850:8]
33217 | | | |--LITERAL_PRIVATE -> private [2850:8]
33218 | | | `--FINAL -> final [2850:16]
33219 | | |--TYPE -> TYPE [2850:35]
33220 | | | `--ARRAY_DECLARATOR -> [ [2850:35]
33221 | | | |--IDENT -> IndentComment [2850:22]
33222 | | | `--RBRACK -> ] [2850:36]
33223 | | |--IDENT -> comments [2850:38]
33224 | | `--SEMI -> ; [2850:46]
33225 | |--VARIABLE_DEF -> VARIABLE_DEF [2851:8]
33226 | | |--MODIFIERS -> MODIFIERS [2851:8]
33227 | | | `--LITERAL_PRIVATE -> private [2851:8]
33228 | | |--TYPE -> TYPE [2851:16]
33229 | | | `--LITERAL_INT -> int [2851:16]
33230 | | |--IDENT -> position [2851:20]
33231 | | `--SEMI -> ; [2851:28]
33232 | |--CTOR_DEF -> CTOR_DEF [2853:22]
33233 | | |--MODIFIERS -> MODIFIERS [2853:22]
33234 | | |--BLOCK_COMMENT_BEGIN -> /* [2853:8]
33235 | | | |--COMMENT_CONTENT -> package [2853:10]
33236 | | | `--BLOCK_COMMENT_END -> */ [2853:18]
33237 | | |--IDENT -> IndentAudit [2853:22]
33238 | | |--LPAREN -> ( [2853:33]
33239 | | |--PARAMETERS -> PARAMETERS [2853:34]
33240 | | | `--PARAMETER_DEF -> PARAMETER_DEF [2853:34]
33241 | | | |--MODIFIERS -> MODIFIERS [2853:34]
33242 | | | |--TYPE -> TYPE [2853:34]
33243 | | | | `--IDENT -> IndentComment [2853:34]
33244 | | | |--ELLIPSIS -> ... [2853:47]
33245 | | | `--IDENT -> comments [2853:51]
33246 | | |--RPAREN -> ) [2853:59]
33247 | | `--SLIST -> { [2853:61]
33248 | | |--EXPR -> EXPR [2854:26]
33249 | | | `--ASSIGN -> = [2854:26]
33250 | | | |--DOT -> . [2854:16]
33251 | | | | |--LITERAL_THIS -> this [2854:12]
33252 | | | | `--IDENT -> comments [2854:17]
33253 | | | `--METHOD_CALL -> ( [2854:41]
33254 | | | |--DOT -> . [2854:34]
33255 | | | | |--IDENT -> Arrays [2854:28]
33256 | | | | `--IDENT -> copyOf [2854:35]
33257 | | | |--ELIST -> ELIST [2854:42]
33258 | | | | |--EXPR -> EXPR [2854:42]
33259 | | | | | `--IDENT -> comments [2854:42]
33260 | | | | |--COMMA -> , [2854:50]
33261 | | | | `--EXPR -> EXPR [2854:60]
33262 | | | | `--DOT -> . [2854:60]
33263 | | | | |--IDENT -> comments [2854:52]
33264 | | | | `--IDENT -> length [2854:61]
33265 | | | `--RPAREN -> ) [2854:67]
33266 | | |--SEMI -> ; [2854:68]
33267 | | `--RCURLY -> } [2855:8]
33268 | |--METHOD_DEF -> METHOD_DEF [2857:8]
33269 | | |--MODIFIERS -> MODIFIERS [2857:8]
33270 | | | |--ANNOTATION -> ANNOTATION [2857:8]
33271 | | | | |--AT -> @ [2857:8]
33272 | | | | `--IDENT -> Override [2857:9]
33273 | | | `--LITERAL_PUBLIC -> public [2858:8]
33274 | | |--TYPE -> TYPE [2858:15]
33275 | | | `--LITERAL_VOID -> void [2858:15]
33276 | | |--IDENT -> auditStarted [2858:20]
33277 | | |--LPAREN -> ( [2858:32]
33278 | | |--PARAMETERS -> PARAMETERS [2858:33]
33279 | | | `--PARAMETER_DEF -> PARAMETER_DEF [2858:33]
33280 | | | |--MODIFIERS -> MODIFIERS [2858:33]
33281 | | | |--TYPE -> TYPE [2858:33]
33282 | | | | `--IDENT -> AuditEvent [2858:33]
33283 | | | `--IDENT -> event [2858:44]
33284 | | |--RPAREN -> ) [2858:49]
33285 | | `--SLIST -> { [2858:51]
33286 | | |--SINGLE_LINE_COMMENT -> // [2859:12]
33287 | | | `--COMMENT_CONTENT -> No code needed\n [2859:14]
33288 | | `--RCURLY -> } [2860:8]
33289 | |--METHOD_DEF -> METHOD_DEF [2862:8]
33290 | | |--MODIFIERS -> MODIFIERS [2862:8]
33291 | | | |--ANNOTATION -> ANNOTATION [2862:8]
33292 | | | | |--AT -> @ [2862:8]
33293 | | | | `--IDENT -> Override [2862:9]
33294 | | | `--LITERAL_PUBLIC -> public [2863:8]
33295 | | |--TYPE -> TYPE [2863:15]
33296 | | | `--LITERAL_VOID -> void [2863:15]
33297 | | |--IDENT -> auditFinished [2863:20]
33298 | | |--LPAREN -> ( [2863:33]
33299 | | |--PARAMETERS -> PARAMETERS [2863:34]
33300 | | | `--PARAMETER_DEF -> PARAMETER_DEF [2863:34]
33301 | | | |--MODIFIERS -> MODIFIERS [2863:34]
33302 | | | |--TYPE -> TYPE [2863:34]
33303 | | | | `--IDENT -> AuditEvent [2863:34]
33304 | | | `--IDENT -> event [2863:45]
33305 | | |--RPAREN -> ) [2863:50]
33306 | | `--SLIST -> { [2863:52]
33307 | | |--SINGLE_LINE_COMMENT -> // [2864:12]
33308 | | | `--COMMENT_CONTENT -> No code needed\n [2864:14]
33309 | | `--RCURLY -> } [2865:8]
33310 | |--METHOD_DEF -> METHOD_DEF [2867:8]
33311 | | |--MODIFIERS -> MODIFIERS [2867:8]
33312 | | | |--ANNOTATION -> ANNOTATION [2867:8]
33313 | | | | |--AT -> @ [2867:8]
33314 | | | | `--IDENT -> Override [2867:9]
33315 | | | `--LITERAL_PUBLIC -> public [2868:8]
33316 | | |--TYPE -> TYPE [2868:15]
33317 | | | `--LITERAL_VOID -> void [2868:15]
33318 | | |--IDENT -> fileStarted [2868:20]
33319 | | |--LPAREN -> ( [2868:31]
33320 | | |--PARAMETERS -> PARAMETERS [2868:32]
33321 | | | `--PARAMETER_DEF -> PARAMETER_DEF [2868:32]
33322 | | | |--MODIFIERS -> MODIFIERS [2868:32]
33323 | | | |--TYPE -> TYPE [2868:32]
33324 | | | | `--IDENT -> AuditEvent [2868:32]
33325 | | | `--IDENT -> event [2868:43]
33326 | | |--RPAREN -> ) [2868:48]
33327 | | `--SLIST -> { [2868:50]
33328 | | |--SINGLE_LINE_COMMENT -> // [2869:12]
33329 | | | `--COMMENT_CONTENT -> No code needed\n [2869:14]
33330 | | `--RCURLY -> } [2870:8]
33331 | |--METHOD_DEF -> METHOD_DEF [2872:8]
33332 | | |--MODIFIERS -> MODIFIERS [2872:8]
33333 | | | |--ANNOTATION -> ANNOTATION [2872:8]
33334 | | | | |--AT -> @ [2872:8]
33335 | | | | `--IDENT -> Override [2872:9]
33336 | | | `--LITERAL_PUBLIC -> public [2873:8]
33337 | | |--TYPE -> TYPE [2873:15]
33338 | | | `--LITERAL_VOID -> void [2873:15]
33339 | | |--IDENT -> fileFinished [2873:20]
33340 | | |--LPAREN -> ( [2873:32]
33341 | | |--PARAMETERS -> PARAMETERS [2873:33]
33342 | | | `--PARAMETER_DEF -> PARAMETER_DEF [2873:33]
33343 | | | |--MODIFIERS -> MODIFIERS [2873:33]
33344 | | | |--TYPE -> TYPE [2873:33]
33345 | | | | `--IDENT -> AuditEvent [2873:33]
33346 | | | `--IDENT -> event [2873:44]
33347 | | |--RPAREN -> ) [2873:49]
33348 | | `--SLIST -> { [2873:51]
33349 | | |--SINGLE_LINE_COMMENT -> // [2874:12]
33350 | | | `--COMMENT_CONTENT -> No code needed\n [2874:14]
33351 | | `--RCURLY -> } [2875:8]
33352 | |--METHOD_DEF -> METHOD_DEF [2877:8]
33353 | | |--MODIFIERS -> MODIFIERS [2877:8]
33354 | | | |--ANNOTATION -> ANNOTATION [2877:8]
33355 | | | | |--AT -> @ [2877:8]
33356 | | | | `--IDENT -> Override [2877:9]
33357 | | | `--LITERAL_PUBLIC -> public [2878:8]
33358 | | |--TYPE -> TYPE [2878:15]
33359 | | | `--LITERAL_VOID -> void [2878:15]
33360 | | |--IDENT -> addError [2878:20]
33361 | | |--LPAREN -> ( [2878:28]
33362 | | |--PARAMETERS -> PARAMETERS [2878:29]
33363 | | | `--PARAMETER_DEF -> PARAMETER_DEF [2878:29]
33364 | | | |--MODIFIERS -> MODIFIERS [2878:29]
33365 | | | |--TYPE -> TYPE [2878:29]
33366 | | | | `--IDENT -> AuditEvent [2878:29]
33367 | | | `--IDENT -> event [2878:40]
33368 | | |--RPAREN -> ) [2878:45]
33369 | | `--SLIST -> { [2878:47]
33370 | | |--VARIABLE_DEF -> VARIABLE_DEF [2879:12]
33371 | | | |--MODIFIERS -> MODIFIERS [2879:12]
33372 | | | | `--FINAL -> final [2879:12]
33373 | | | |--TYPE -> TYPE [2879:18]
33374 | | | | `--LITERAL_INT -> int [2879:18]
33375 | | | |--IDENT -> line [2879:22]
33376 | | | `--ASSIGN -> = [2879:27]
33377 | | | `--EXPR -> EXPR [2879:42]
33378 | | | `--METHOD_CALL -> ( [2879:42]
33379 | | | |--DOT -> . [2879:34]
33380 | | | | |--IDENT -> event [2879:29]
33381 | | | | `--IDENT -> getLine [2879:35]
33382 | | | |--ELIST -> ELIST [2879:43]
33383 | | | `--RPAREN -> ) [2879:43]
33384 | | |--SEMI -> ; [2879:44]
33385 | | |--VARIABLE_DEF -> VARIABLE_DEF [2880:12]
33386 | | | |--MODIFIERS -> MODIFIERS [2880:12]
33387 | | | | `--FINAL -> final [2880:12]
33388 | | | |--TYPE -> TYPE [2880:18]
33389 | | | | `--IDENT -> String [2880:18]
33390 | | | |--IDENT -> message [2880:25]
33391 | | | `--ASSIGN -> = [2880:33]
33392 | | | `--EXPR -> EXPR [2880:51]
33393 | | | `--METHOD_CALL -> ( [2880:51]
33394 | | | |--DOT -> . [2880:40]
33395 | | | | |--IDENT -> event [2880:35]
33396 | | | | `--IDENT -> getMessage [2880:41]
33397 | | | |--ELIST -> ELIST [2880:52]
33398 | | | `--RPAREN -> ) [2880:52]
33399 | | |--SEMI -> ; [2880:53]
33400 | | |--LITERAL_IF -> if [2882:12]
33401 | | | |--LPAREN -> ( [2882:15]
33402 | | | |--EXPR -> EXPR [2882:25]
33403 | | | | `--GE -> >= [2882:25]
33404 | | | | |--IDENT -> position [2882:16]
33405 | | | | `--DOT -> . [2882:36]
33406 | | | | |--IDENT -> comments [2882:28]
33407 | | | | `--IDENT -> length [2882:37]
33408 | | | |--RPAREN -> ) [2882:43]
33409 | | | `--SLIST -> { [2882:45]
33410 | | | |--EXPR -> EXPR [2883:20]
33411 | | | | `--METHOD_CALL -> ( [2883:20]
33412 | | | | |--IDENT -> fail [2883:16]
33413 | | | | |--ELIST -> ELIST [2884:43]
33414 | | | | | `--EXPR -> EXPR [2884:43]
33415 | | | | | `--PLUS -> + [2884:43]
33416 | | | | | |--PLUS -> + [2884:24]
33417 | | | | | | |--PLUS -> + [2883:93]
33418 | | | | | | | |--PLUS -> + [2883:79]
33419 | | | | | | | | |--PLUS -> + [2883:68]
33420 | | | | | | | | | |--STRING_LITERAL -> "found a warning when none was expected for #" [2883:21]
33421 | | | | | | | | | `--IDENT -> position [2883:70]
33422 | | | | | | | | `--STRING_LITERAL -> " at line " [2883:81]
33423 | | | | | | | `--IDENT -> line [2883:95]
33424 | | | | | | `--STRING_LITERAL -> " with message " [2884:26]
33425 | | | | | `--IDENT -> message [2884:45]
33426 | | | | `--RPAREN -> ) [2884:52]
33427 | | | |--SEMI -> ; [2884:53]
33428 | | | `--RCURLY -> } [2885:12]
33429 | | |--VARIABLE_DEF -> VARIABLE_DEF [2887:12]
33430 | | | |--MODIFIERS -> MODIFIERS [2887:12]
33431 | | | | `--FINAL -> final [2887:12]
33432 | | | |--TYPE -> TYPE [2887:18]
33433 | | | | `--IDENT -> IndentComment [2887:18]
33434 | | | |--IDENT -> comment [2887:32]
33435 | | | `--ASSIGN -> = [2887:40]
33436 | | | `--EXPR -> EXPR [2887:50]
33437 | | | `--INDEX_OP -> [ [2887:50]
33438 | | | |--IDENT -> comments [2887:42]
33439 | | | |--EXPR -> EXPR [2887:51]
33440 | | | | `--IDENT -> position [2887:51]
33441 | | | `--RBRACK -> ] [2887:59]
33442 | | |--SEMI -> ; [2887:60]
33443 | | |--EXPR -> EXPR [2888:20]
33444 | | | `--POST_INC -> ++ [2888:20]
33445 | | | `--IDENT -> position [2888:12]
33446 | | |--SEMI -> ; [2888:22]
33447 | | |--VARIABLE_DEF -> VARIABLE_DEF [2890:12]
33448 | | | |--MODIFIERS -> MODIFIERS [2890:12]
33449 | | | | `--FINAL -> final [2890:12]
33450 | | | |--TYPE -> TYPE [2890:18]
33451 | | | | `--IDENT -> String [2890:18]
33452 | | | |--IDENT -> possibleExceptedMessages [2890:25]
33453 | | | `--ASSIGN -> = [2890:50]
33454 | | | `--EXPR -> EXPR [2891:27]
33455 | | | `--METHOD_CALL -> ( [2891:27]
33456 | | | |--DOT -> . [2891:20]
33457 | | | | |--METHOD_CALL -> ( [2890:65]
33458 | | | | | |--DOT -> . [2890:58]
33459 | | | | | | |--IDENT -> Arrays [2890:52]
33460 | | | | | | `--IDENT -> stream [2890:59]
33461 | | | | | |--ELIST -> ELIST [2890:93]
33462 | | | | | | `--EXPR -> EXPR [2890:93]
33463 | | | | | | `--METHOD_CALL -> ( [2890:93]
33464 | | | | | | |--DOT -> . [2890:73]
33465 | | | | | | | |--IDENT -> comment [2890:66]
33466 | | | | | | | `--IDENT -> getExpectedMessages [2890:74]
33467 | | | | | | |--ELIST -> ELIST [2890:94]
33468 | | | | | | `--RPAREN -> ) [2890:94]
33469 | | | | | `--RPAREN -> ) [2890:95]
33470 | | | | `--IDENT -> reduce [2891:21]
33471 | | | |--ELIST -> ELIST [2891:28]
33472 | | | | |--EXPR -> EXPR [2891:28]
33473 | | | | | `--STRING_LITERAL -> "" [2891:28]
33474 | | | | |--COMMA -> , [2891:30]
33475 | | | | `--LAMBDA -> -> [2891:44]
33476 | | | | |--LPAREN -> ( [2891:32]
33477 | | | | |--PARAMETERS -> PARAMETERS [2891:33]
33478 | | | | | |--PARAMETER_DEF -> PARAMETER_DEF [2891:33]
33479 | | | | | | |--MODIFIERS -> MODIFIERS [2891:33]
33480 | | | | | | |--TYPE -> TYPE [2891:33]
33481 | | | | | | `--IDENT -> cur [2891:33]
33482 | | | | | |--COMMA -> , [2891:36]
33483 | | | | | `--PARAMETER_DEF -> PARAMETER_DEF [2891:38]
33484 | | | | | |--MODIFIERS -> MODIFIERS [2891:38]
33485 | | | | | |--TYPE -> TYPE [2891:38]
33486 | | | | | `--IDENT -> next [2891:38]
33487 | | | | |--RPAREN -> ) [2891:42]
33488 | | | | `--EXPR -> EXPR [2891:65]
33489 | | | | `--PLUS -> + [2891:65]
33490 | | | | |--PLUS -> + [2891:58]
33491 | | | | | |--PLUS -> + [2891:51]
33492 | | | | | | |--IDENT -> cur [2891:47]
33493 | | | | | | `--STRING_LITERAL -> "\"" [2891:53]
33494 | | | | | `--IDENT -> next [2891:60]
33495 | | | | `--STRING_LITERAL -> "\", " [2891:67]
33496 | | | `--RPAREN -> ) [2891:73]
33497 | | |--SEMI -> ; [2891:74]
33498 | | |--VARIABLE_DEF -> VARIABLE_DEF [2892:12]
33499 | | | |--MODIFIERS -> MODIFIERS [2892:12]
33500 | | | | `--FINAL -> final [2892:12]
33501 | | | |--TYPE -> TYPE [2892:18]
33502 | | | | `--IDENT -> String [2892:18]
33503 | | | |--IDENT -> assertMessage [2892:25]
33504 | | | `--ASSIGN -> = [2892:39]
33505 | | | `--EXPR -> EXPR [2892:54]
33506 | | | `--METHOD_CALL -> ( [2892:54]
33507 | | | |--DOT -> . [2892:47]
33508 | | | | |--IDENT -> String [2892:41]
33509 | | | | `--IDENT -> format [2892:48]
33510 | | | |--ELIST -> ELIST [2893:26]
33511 | | | | |--EXPR -> EXPR [2893:26]
33512 | | | | | `--DOT -> . [2893:26]
33513 | | | | | |--IDENT -> Locale [2893:20]
33514 | | | | | `--IDENT -> ROOT [2893:27]
33515 | | | | |--COMMA -> , [2893:31]
33516 | | | | |--EXPR -> EXPR [2895:28]
33517 | | | | | `--PLUS -> + [2895:28]
33518 | | | | | |--STRING_LITERAL -> "input expected warning #%d at line %d to report one of the following: %s" [2894:20]
33519 | | | | | `--STRING_LITERAL -> "but got instead: %d: %s" [2895:30]
33520 | | | | |--COMMA -> , [2895:55]
33521 | | | | |--EXPR -> EXPR [2896:20]
33522 | | | | | `--IDENT -> position [2896:20]
33523 | | | | |--COMMA -> , [2896:28]
33524 | | | | |--EXPR -> EXPR [2896:51]
33525 | | | | | `--METHOD_CALL -> ( [2896:51]
33526 | | | | | |--DOT -> . [2896:37]
33527 | | | | | | |--IDENT -> comment [2896:30]
33528 | | | | | | `--IDENT -> getLineNumber [2896:38]
33529 | | | | | |--ELIST -> ELIST [2896:52]
33530 | | | | | `--RPAREN -> ) [2896:52]
33531 | | | | |--COMMA -> , [2896:53]
33532 | | | | |--EXPR -> EXPR [2896:55]
33533 | | | | | `--IDENT -> possibleExceptedMessages [2896:55]
33534 | | | | |--COMMA -> , [2896:79]
33535 | | | | |--EXPR -> EXPR [2896:81]
33536 | | | | | `--IDENT -> line [2896:81]
33537 | | | | |--COMMA -> , [2896:85]
33538 | | | | `--EXPR -> EXPR [2896:87]
33539 | | | | `--IDENT -> message [2896:87]
33540 | | | `--RPAREN -> ) [2896:94]
33541 | | |--SEMI -> ; [2896:95]
33542 | | |--EXPR -> EXPR [2897:22]
33543 | | | `--METHOD_CALL -> ( [2897:22]
33544 | | | |--IDENT -> assertTrue [2897:12]
33545 | | | |--ELIST -> ELIST [2898:20]
33546 | | | | |--EXPR -> EXPR [2898:20]
33547 | | | | | `--LAND -> && [2898:20]
33548 | | | | | |--EQUAL -> == [2897:28]
33549 | | | | | | |--IDENT -> line [2897:23]
33550 | | | | | | `--METHOD_CALL -> ( [2897:52]
33551 | | | | | | |--DOT -> . [2897:38]
33552 | | | | | | | |--IDENT -> comment [2897:31]
33553 | | | | | | | `--IDENT -> getLineNumber [2897:39]
33554 | | | | | | |--ELIST -> ELIST [2897:53]
33555 | | | | | | `--RPAREN -> ) [2897:53]
33556 | | | | | `--METHOD_CALL -> ( [2898:76]
33557 | | | | | |--DOT -> . [2898:67]
33558 | | | | | | |--METHOD_CALL -> ( [2898:36]
33559 | | | | | | | |--DOT -> . [2898:29]
33560 | | | | | | | | |--IDENT -> Arrays [2898:23]
33561 | | | | | | | | `--IDENT -> stream [2898:30]
33562 | | | | | | | |--ELIST -> ELIST [2898:64]
33563 | | | | | | | | `--EXPR -> EXPR [2898:64]
33564 | | | | | | | | `--METHOD_CALL -> ( [2898:64]
33565 | | | | | | | | |--DOT -> . [2898:44]
33566 | | | | | | | | | |--IDENT -> comment [2898:37]
33567 | | | | | | | | | `--IDENT -> getExpectedMessages [2898:45]
33568 | | | | | | | | |--ELIST -> ELIST [2898:65]
33569 | | | | | | | | `--RPAREN -> ) [2898:65]
33570 | | | | | | | `--RPAREN -> ) [2898:66]
33571 | | | | | | `--IDENT -> anyMatch [2898:68]
33572 | | | | | |--ELIST -> ELIST [2898:84]
33573 | | | | | | `--EXPR -> EXPR [2898:84]
33574 | | | | | | `--METHOD_REF -> :: [2898:84]
33575 | | | | | | |--IDENT -> message [2898:77]
33576 | | | | | | `--IDENT -> endsWith [2898:86]
33577 | | | | | `--RPAREN -> ) [2898:94]
33578 | | | | |--COMMA -> , [2898:95]
33579 | | | | `--EXPR -> EXPR [2899:20]
33580 | | | | `--IDENT -> assertMessage [2899:20]
33581 | | | `--RPAREN -> ) [2899:33]
33582 | | |--SEMI -> ; [2899:34]
33583 | | `--RCURLY -> } [2900:8]
33584 | |--METHOD_DEF -> METHOD_DEF [2902:8]
33585 | | |--MODIFIERS -> MODIFIERS [2902:8]
33586 | | | |--ANNOTATION -> ANNOTATION [2902:8]
33587 | | | | |--AT -> @ [2902:8]
33588 | | | | `--IDENT -> Override [2902:9]
33589 | | | `--LITERAL_PUBLIC -> public [2903:8]
33590 | | |--TYPE -> TYPE [2903:15]
33591 | | | `--LITERAL_VOID -> void [2903:15]
33592 | | |--IDENT -> addException [2903:20]
33593 | | |--LPAREN -> ( [2903:32]
33594 | | |--PARAMETERS -> PARAMETERS [2903:33]
33595 | | | |--PARAMETER_DEF -> PARAMETER_DEF [2903:33]
33596 | | | | |--MODIFIERS -> MODIFIERS [2903:33]
33597 | | | | |--TYPE -> TYPE [2903:33]
33598 | | | | | `--IDENT -> AuditEvent [2903:33]
33599 | | | | `--IDENT -> event [2903:44]
33600 | | | |--COMMA -> , [2903:49]
33601 | | | `--PARAMETER_DEF -> PARAMETER_DEF [2903:51]
33602 | | | |--MODIFIERS -> MODIFIERS [2903:51]
33603 | | | |--TYPE -> TYPE [2903:51]
33604 | | | | `--IDENT -> Throwable [2903:51]
33605 | | | `--IDENT -> throwable [2903:61]
33606 | | |--RPAREN -> ) [2903:70]
33607 | | `--SLIST -> { [2903:72]
33608 | | |--SINGLE_LINE_COMMENT -> // [2904:12]
33609 | | | `--COMMENT_CONTENT -> No code needed\n [2904:14]
33610 | | `--RCURLY -> } [2905:8]
33611 | `--RCURLY -> } [2907:4]
33612 |--CLASS_DEF -> CLASS_DEF [2909:4]
33613 | |--MODIFIERS -> MODIFIERS [2909:4]
33614 | | |--LITERAL_PRIVATE -> private [2909:4]
33615 | | |--LITERAL_STATIC -> static [2909:12]
33616 | | `--FINAL -> final [2909:19]
33617 | |--LITERAL_CLASS -> class [2909:25]
33618 | |--IDENT -> IndentComment [2909:31]
33619 | `--OBJBLOCK -> OBJBLOCK [2909:45]
33620 | |--LCURLY -> { [2909:45]
33621 | |--VARIABLE_DEF -> VARIABLE_DEF [2912:8]
33622 | | |--MODIFIERS -> MODIFIERS [2912:8]
33623 | | | |--BLOCK_COMMENT_BEGIN -> /* [2911:8]
33624 | | | | |--COMMENT_CONTENT -> * Used to locate the index of argument zero of error messages. [2911:10]
33625 | | | | | `--JAVADOC -> JAVADOC [2911:11]
33626 | | | | | |--TEXT -> Used to locate the index of argument zero of error messages. [2911:11]
33627 | | | | | `--EOF -> <EOF> [2911:73]
33628 | | | | `--BLOCK_COMMENT_END -> */ [2911:72]
33629 | | | |--LITERAL_PRIVATE -> private [2912:8]
33630 | | | |--LITERAL_STATIC -> static [2912:16]
33631 | | | `--FINAL -> final [2912:23]
33632 | | |--TYPE -> TYPE [2912:29]
33633 | | | `--IDENT -> String [2912:29]
33634 | | |--IDENT -> FAKE_ARGUMENT_ZERO [2912:36]
33635 | | |--ASSIGN -> = [2912:55]
33636 | | | `--EXPR -> EXPR [2912:57]
33637 | | | `--STRING_LITERAL -> "##0##" [2912:57]
33638 | | `--SEMI -> ; [2912:64]
33639 | |--VARIABLE_DEF -> VARIABLE_DEF [2913:8]
33640 | | |--MODIFIERS -> MODIFIERS [2913:8]
33641 | | | |--LITERAL_PRIVATE -> private [2913:8]
33642 | | | `--FINAL -> final [2913:16]
33643 | | |--TYPE -> TYPE [2913:22]
33644 | | | `--LITERAL_INT -> int [2913:22]
33645 | | |--IDENT -> lineNumber [2913:26]
33646 | | `--SEMI -> ; [2913:36]
33647 | |--VARIABLE_DEF -> VARIABLE_DEF [2914:8]
33648 | | |--MODIFIERS -> MODIFIERS [2914:8]
33649 | | | |--LITERAL_PRIVATE -> private [2914:8]
33650 | | | `--FINAL -> final [2914:16]
33651 | | |--TYPE -> TYPE [2914:22]
33652 | | | `--LITERAL_INT -> int [2914:22]
33653 | | |--IDENT -> indent [2914:26]
33654 | | `--SEMI -> ; [2914:32]
33655 | |--VARIABLE_DEF -> VARIABLE_DEF [2916:8]
33656 | | |--MODIFIERS -> MODIFIERS [2916:8]
33657 | | | |--BLOCK_COMMENT_BEGIN -> /* [2915:8]
33658 | | | | |--COMMENT_CONTENT -> * Used for when violations report nodes not first on the line. [2915:10]
33659 | | | | | `--JAVADOC -> JAVADOC [2915:11]
33660 | | | | | |--TEXT -> Used for when violations report nodes not first on the line. [2915:11]
33661 | | | | | `--EOF -> <EOF> [2915:73]
33662 | | | | `--BLOCK_COMMENT_END -> */ [2915:72]
33663 | | | |--LITERAL_PRIVATE -> private [2916:8]
33664 | | | `--FINAL -> final [2916:16]
33665 | | |--TYPE -> TYPE [2916:22]
33666 | | | `--LITERAL_INT -> int [2916:22]
33667 | | |--IDENT -> indentOffset [2916:26]
33668 | | `--SEMI -> ; [2916:38]
33669 | |--VARIABLE_DEF -> VARIABLE_DEF [2917:8]
33670 | | |--MODIFIERS -> MODIFIERS [2917:8]
33671 | | | |--LITERAL_PRIVATE -> private [2917:8]
33672 | | | `--FINAL -> final [2917:16]
33673 | | |--TYPE -> TYPE [2917:22]
33674 | | | `--LITERAL_BOOLEAN -> boolean [2917:22]
33675 | | |--IDENT -> expectedNonStrict [2917:30]
33676 | | `--SEMI -> ; [2917:47]
33677 | |--VARIABLE_DEF -> VARIABLE_DEF [2918:8]
33678 | | |--MODIFIERS -> MODIFIERS [2918:8]
33679 | | | |--LITERAL_PRIVATE -> private [2918:8]
33680 | | | `--FINAL -> final [2918:16]
33681 | | |--TYPE -> TYPE [2918:22]
33682 | | | `--IDENT -> String [2918:22]
33683 | | |--IDENT -> expectedWarning [2918:29]
33684 | | `--SEMI -> ; [2918:44]
33685 | |--VARIABLE_DEF -> VARIABLE_DEF [2919:8]
33686 | | |--MODIFIERS -> MODIFIERS [2919:8]
33687 | | | |--LITERAL_PRIVATE -> private [2919:8]
33688 | | | `--FINAL -> final [2919:16]
33689 | | |--TYPE -> TYPE [2919:22]
33690 | | | `--LITERAL_BOOLEAN -> boolean [2919:22]
33691 | | |--IDENT -> warning [2919:30]
33692 | | `--SEMI -> ; [2919:37]
33693 | |--CTOR_DEF -> CTOR_DEF [2921:22]
33694 | | |--MODIFIERS -> MODIFIERS [2921:22]
33695 | | |--BLOCK_COMMENT_BEGIN -> /* [2921:8]
33696 | | | |--COMMENT_CONTENT -> package [2921:10]
33697 | | | `--BLOCK_COMMENT_END -> */ [2921:18]
33698 | | |--IDENT -> IndentComment [2921:22]
33699 | | |--LPAREN -> ( [2921:35]
33700 | | |--PARAMETERS -> PARAMETERS [2921:36]
33701 | | | |--PARAMETER_DEF -> PARAMETER_DEF [2921:36]
33702 | | | | |--MODIFIERS -> MODIFIERS [2921:36]
33703 | | | | |--TYPE -> TYPE [2921:36]
33704 | | | | | `--IDENT -> Matcher [2921:36]
33705 | | | | `--IDENT -> match [2921:44]
33706 | | | |--COMMA -> , [2921:49]
33707 | | | `--PARAMETER_DEF -> PARAMETER_DEF [2921:51]
33708 | | | |--MODIFIERS -> MODIFIERS [2921:51]
33709 | | | |--TYPE -> TYPE [2921:51]
33710 | | | | `--LITERAL_INT -> int [2921:51]
33711 | | | `--IDENT -> lineNumber [2921:55]
33712 | | |--RPAREN -> ) [2921:65]
33713 | | `--SLIST -> { [2921:67]
33714 | | |--EXPR -> EXPR [2922:28]
33715 | | | `--ASSIGN -> = [2922:28]
33716 | | | |--DOT -> . [2922:16]
33717 | | | | |--LITERAL_THIS -> this [2922:12]
33718 | | | | `--IDENT -> lineNumber [2922:17]
33719 | | | `--IDENT -> lineNumber [2922:30]
33720 | | |--SEMI -> ; [2922:40]
33721 | | |--EXPR -> EXPR [2923:19]
33722 | | | `--ASSIGN -> = [2923:19]
33723 | | | |--IDENT -> indent [2923:12]
33724 | | | `--METHOD_CALL -> ( [2923:37]
33725 | | | |--DOT -> . [2923:28]
33726 | | | | |--IDENT -> Integer [2923:21]
33727 | | | | `--IDENT -> parseInt [2923:29]
33728 | | | |--ELIST -> ELIST [2923:49]
33729 | | | | `--EXPR -> EXPR [2923:49]
33730 | | | | `--METHOD_CALL -> ( [2923:49]
33731 | | | | |--DOT -> . [2923:43]
33732 | | | | | |--IDENT -> match [2923:38]
33733 | | | | | `--IDENT -> group [2923:44]
33734 | | | | |--ELIST -> ELIST [2923:50]
33735 | | | | | `--EXPR -> EXPR [2923:50]
33736 | | | | | `--NUM_INT -> 1 [2923:50]
33737 | | | | `--RPAREN -> ) [2923:51]
33738 | | | `--RPAREN -> ) [2923:52]
33739 | | |--SEMI -> ; [2923:53]
33740 | | |--LITERAL_IF -> if [2924:12]
33741 | | | |--LPAREN -> ( [2924:15]
33742 | | | |--EXPR -> EXPR [2924:31]
33743 | | | | `--EQUAL -> == [2924:31]
33744 | | | | |--METHOD_CALL -> ( [2924:27]
33745 | | | | | |--DOT -> . [2924:21]
33746 | | | | | | |--IDENT -> match [2924:16]
33747 | | | | | | `--IDENT -> group [2924:22]
33748 | | | | | |--ELIST -> ELIST [2924:28]
33749 | | | | | | `--EXPR -> EXPR [2924:28]
33750 | | | | | | `--NUM_INT -> 2 [2924:28]
33751 | | | | | `--RPAREN -> ) [2924:29]
33752 | | | | `--LITERAL_NULL -> null [2924:34]
33753 | | | |--RPAREN -> ) [2924:38]
33754 | | | |--SLIST -> { [2924:40]
33755 | | | | |--EXPR -> EXPR [2925:29]
33756 | | | | | `--ASSIGN -> = [2925:29]
33757 | | | | | |--IDENT -> indentOffset [2925:16]
33758 | | | | | `--NUM_INT -> 0 [2925:31]
33759 | | | | |--SEMI -> ; [2925:32]
33760 | | | | `--RCURLY -> } [2926:12]
33761 | | | `--LITERAL_ELSE -> else [2927:12]
33762 | | | `--SLIST -> { [2927:17]
33763 | | | |--EXPR -> EXPR [2928:29]
33764 | | | | `--ASSIGN -> = [2928:29]
33765 | | | | |--IDENT -> indentOffset [2928:16]
33766 | | | | `--METHOD_CALL -> ( [2928:47]
33767 | | | | |--DOT -> . [2928:38]
33768 | | | | | |--IDENT -> Integer [2928:31]
33769 | | | | | `--IDENT -> parseInt [2928:39]
33770 | | | | |--ELIST -> ELIST [2928:59]
33771 | | | | | `--EXPR -> EXPR [2928:59]
33772 | | | | | `--METHOD_CALL -> ( [2928:59]
33773 | | | | | |--DOT -> . [2928:53]
33774 | | | | | | |--IDENT -> match [2928:48]
33775 | | | | | | `--IDENT -> group [2928:54]
33776 | | | | | |--ELIST -> ELIST [2928:60]
33777 | | | | | | `--EXPR -> EXPR [2928:60]
33778 | | | | | | `--NUM_INT -> 2 [2928:60]
33779 | | | | | `--RPAREN -> ) [2928:61]
33780 | | | | `--RPAREN -> ) [2928:62]
33781 | | | |--SEMI -> ; [2928:63]
33782 | | | `--RCURLY -> } [2929:12]
33783 | | |--EXPR -> EXPR [2930:30]
33784 | | | `--ASSIGN -> = [2930:30]
33785 | | | |--IDENT -> expectedNonStrict [2930:12]
33786 | | | `--NOT_EQUAL -> != [2930:47]
33787 | | | |--METHOD_CALL -> ( [2930:43]
33788 | | | | |--DOT -> . [2930:37]
33789 | | | | | |--IDENT -> match [2930:32]
33790 | | | | | `--IDENT -> group [2930:38]
33791 | | | | |--ELIST -> ELIST [2930:44]
33792 | | | | | `--EXPR -> EXPR [2930:44]
33793 | | | | | `--NUM_INT -> 3 [2930:44]
33794 | | | | `--RPAREN -> ) [2930:45]
33795 | | | `--LITERAL_NULL -> null [2930:50]
33796 | | |--SEMI -> ; [2930:54]
33797 | | |--EXPR -> EXPR [2931:28]
33798 | | | `--ASSIGN -> = [2931:28]
33799 | | | |--IDENT -> expectedWarning [2931:12]
33800 | | | `--METHOD_CALL -> ( [2931:52]
33801 | | | |--DOT -> . [2931:44]
33802 | | | | |--METHOD_CALL -> ( [2931:41]
33803 | | | | | |--DOT -> . [2931:35]
33804 | | | | | | |--IDENT -> match [2931:30]
33805 | | | | | | `--IDENT -> group [2931:36]
33806 | | | | | |--ELIST -> ELIST [2931:42]
33807 | | | | | | `--EXPR -> EXPR [2931:42]
33808 | | | | | | `--NUM_INT -> 4 [2931:42]
33809 | | | | | `--RPAREN -> ) [2931:43]
33810 | | | | `--IDENT -> replace [2931:45]
33811 | | | |--ELIST -> ELIST [2931:53]
33812 | | | | |--EXPR -> EXPR [2931:53]
33813 | | | | | `--STRING_LITERAL -> "," [2931:53]
33814 | | | | |--COMMA -> , [2931:56]
33815 | | | | `--EXPR -> EXPR [2931:58]
33816 | | | | `--STRING_LITERAL -> ", " [2931:58]
33817 | | | `--RPAREN -> ) [2931:62]
33818 | | |--SEMI -> ; [2931:63]
33819 | | |--EXPR -> EXPR [2932:20]
33820 | | | `--ASSIGN -> = [2932:20]
33821 | | | |--IDENT -> warning [2932:12]
33822 | | | `--NOT_EQUAL -> != [2932:37]
33823 | | | |--METHOD_CALL -> ( [2932:33]
33824 | | | | |--DOT -> . [2932:27]
33825 | | | | | |--IDENT -> match [2932:22]
33826 | | | | | `--IDENT -> group [2932:28]
33827 | | | | |--ELIST -> ELIST [2932:34]
33828 | | | | | `--EXPR -> EXPR [2932:34]
33829 | | | | | `--NUM_INT -> 5 [2932:34]
33830 | | | | `--RPAREN -> ) [2932:35]
33831 | | | `--LITERAL_NULL -> null [2932:40]
33832 | | |--SEMI -> ; [2932:44]
33833 | | `--RCURLY -> } [2933:8]
33834 | |--METHOD_DEF -> METHOD_DEF [2935:8]
33835 | | |--MODIFIERS -> MODIFIERS [2935:8]
33836 | | | `--LITERAL_PUBLIC -> public [2935:8]
33837 | | |--TYPE -> TYPE [2935:21]
33838 | | | `--ARRAY_DECLARATOR -> [ [2935:21]
33839 | | | |--IDENT -> String [2935:15]
33840 | | | `--RBRACK -> ] [2935:22]
33841 | | |--IDENT -> getExpectedMessages [2935:24]
33842 | | |--LPAREN -> ( [2935:43]
33843 | | |--PARAMETERS -> PARAMETERS [2935:44]
33844 | | |--RPAREN -> ) [2935:44]
33845 | | `--SLIST -> { [2935:46]
33846 | | |--VARIABLE_DEF -> VARIABLE_DEF [2936:12]
33847 | | | |--MODIFIERS -> MODIFIERS [2936:12]
33848 | | | | `--FINAL -> final [2936:12]
33849 | | | |--TYPE -> TYPE [2936:24]
33850 | | | | `--ARRAY_DECLARATOR -> [ [2936:24]
33851 | | | | |--IDENT -> String [2936:18]
33852 | | | | `--RBRACK -> ] [2936:25]
33853 | | | `--IDENT -> expectedMessages [2936:27]
33854 | | |--SEMI -> ; [2936:43]
33855 | | |--LITERAL_IF -> if [2937:12]
33856 | | | |--LPAREN -> ( [2937:15]
33857 | | | |--EXPR -> EXPR [2937:40]
33858 | | | | `--METHOD_CALL -> ( [2937:40]
33859 | | | | |--DOT -> . [2937:31]
33860 | | | | | |--IDENT -> expectedWarning [2937:16]
33861 | | | | | `--IDENT -> contains [2937:32]
33862 | | | | |--ELIST -> ELIST [2937:41]
33863 | | | | | `--EXPR -> EXPR [2937:41]
33864 | | | | | `--STRING_LITERAL -> "," [2937:41]
33865 | | | | `--RPAREN -> ) [2937:44]
33866 | | | |--RPAREN -> ) [2937:45]
33867 | | | |--SLIST -> { [2937:47]
33868 | | | | |--EXPR -> EXPR [2938:33]
33869 | | | | | `--ASSIGN -> = [2938:33]
33870 | | | | | |--IDENT -> expectedMessages [2938:16]
33871 | | | | | `--LITERAL_NEW -> new [2938:35]
33872 | | | | | |--IDENT -> String [2938:39]
33873 | | | | | |--ARRAY_DECLARATOR -> [ [2938:45]
33874 | | | | | | `--RBRACK -> ] [2938:46]
33875 | | | | | `--ARRAY_INIT -> { [2938:48]
33876 | | | | | |--EXPR -> EXPR [2939:45]
33877 | | | | | | `--METHOD_CALL -> ( [2939:45]
33878 | | | | | | |--IDENT -> getExpectedMessagePostfix [2939:20]
33879 | | | | | | |--ELIST -> ELIST [2939:46]
33880 | | | | | | | `--EXPR -> EXPR [2939:46]
33881 | | | | | | | `--IDENT -> MSG_ERROR_MULTI [2939:46]
33882 | | | | | | `--RPAREN -> ) [2939:61]
33883 | | | | | |--COMMA -> , [2939:62]
33884 | | | | | |--EXPR -> EXPR [2940:45]
33885 | | | | | | `--METHOD_CALL -> ( [2940:45]
33886 | | | | | | |--IDENT -> getExpectedMessagePostfix [2940:20]
33887 | | | | | | |--ELIST -> ELIST [2940:46]
33888 | | | | | | | `--EXPR -> EXPR [2940:46]
33889 | | | | | | | `--IDENT -> MSG_CHILD_ERROR_MULTI [2940:46]
33890 | | | | | | `--RPAREN -> ) [2940:67]
33891 | | | | | |--COMMA -> , [2940:68]
33892 | | | | | `--RCURLY -> } [2941:16]
33893 | | | | |--SEMI -> ; [2941:17]
33894 | | | | `--RCURLY -> } [2942:12]
33895 | | | `--LITERAL_ELSE -> else [2943:12]
33896 | | | `--SLIST -> { [2943:17]
33897 | | | |--EXPR -> EXPR [2944:33]
33898 | | | | `--ASSIGN -> = [2944:33]
33899 | | | | |--IDENT -> expectedMessages [2944:16]
33900 | | | | `--LITERAL_NEW -> new [2944:35]
33901 | | | | |--IDENT -> String [2944:39]
33902 | | | | |--ARRAY_DECLARATOR -> [ [2944:45]
33903 | | | | | `--RBRACK -> ] [2944:46]
33904 | | | | `--ARRAY_INIT -> { [2944:48]
33905 | | | | |--EXPR -> EXPR [2945:45]
33906 | | | | | `--METHOD_CALL -> ( [2945:45]
33907 | | | | | |--IDENT -> getExpectedMessagePostfix [2945:20]
33908 | | | | | |--ELIST -> ELIST [2945:46]
33909 | | | | | | `--EXPR -> EXPR [2945:46]
33910 | | | | | | `--IDENT -> MSG_ERROR [2945:46]
33911 | | | | | `--RPAREN -> ) [2945:55]
33912 | | | | |--COMMA -> , [2945:56]
33913 | | | | |--EXPR -> EXPR [2946:45]
33914 | | | | | `--METHOD_CALL -> ( [2946:45]
33915 | | | | | |--IDENT -> getExpectedMessagePostfix [2946:20]
33916 | | | | | |--ELIST -> ELIST [2946:46]
33917 | | | | | | `--EXPR -> EXPR [2946:46]
33918 | | | | | | `--IDENT -> MSG_CHILD_ERROR [2946:46]
33919 | | | | | `--RPAREN -> ) [2946:61]
33920 | | | | |--COMMA -> , [2946:62]
33921 | | | | `--RCURLY -> } [2947:16]
33922 | | | |--SEMI -> ; [2947:17]
33923 | | | `--RCURLY -> } [2948:12]
33924 | | |--LITERAL_RETURN -> return [2949:12]
33925 | | | |--EXPR -> EXPR [2949:19]
33926 | | | | `--IDENT -> expectedMessages [2949:19]
33927 | | | `--SEMI -> ; [2949:35]
33928 | | `--RCURLY -> } [2950:8]
33929 | |--METHOD_DEF -> METHOD_DEF [2952:8]
33930 | | |--MODIFIERS -> MODIFIERS [2952:8]
33931 | | | `--LITERAL_PRIVATE -> private [2952:8]
33932 | | |--TYPE -> TYPE [2952:16]
33933 | | | `--IDENT -> String [2952:16]
33934 | | |--IDENT -> getExpectedMessagePostfix [2952:23]
33935 | | |--LPAREN -> ( [2952:48]
33936 | | |--PARAMETERS -> PARAMETERS [2952:49]
33937 | | | `--PARAMETER_DEF -> PARAMETER_DEF [2952:49]
33938 | | | |--MODIFIERS -> MODIFIERS [2952:49]
33939 | | | | `--FINAL -> final [2952:49]
33940 | | | |--TYPE -> TYPE [2952:55]
33941 | | | | `--IDENT -> String [2952:55]
33942 | | | `--IDENT -> messageKey [2952:62]
33943 | | |--RPAREN -> ) [2952:72]
33944 | | `--SLIST -> { [2952:74]
33945 | | |--VARIABLE_DEF -> VARIABLE_DEF [2953:12]
33946 | | | |--MODIFIERS -> MODIFIERS [2953:12]
33947 | | | | `--FINAL -> final [2953:12]
33948 | | | |--TYPE -> TYPE [2953:18]
33949 | | | | `--IDENT -> String [2953:18]
33950 | | | |--IDENT -> msg [2953:25]
33951 | | | `--ASSIGN -> = [2953:29]
33952 | | | `--EXPR -> EXPR [2953:46]
33953 | | | `--METHOD_CALL -> ( [2953:46]
33954 | | | |--IDENT -> getCheckMessage [2953:31]
33955 | | | |--ELIST -> ELIST [2953:63]
33956 | | | | |--EXPR -> EXPR [2953:63]
33957 | | | | | `--DOT -> . [2953:63]
33958 | | | | | |--IDENT -> IndentationCheck [2953:47]
33959 | | | | | `--LITERAL_CLASS -> class [2953:64]
33960 | | | | |--COMMA -> , [2953:69]
33961 | | | | |--EXPR -> EXPR [2953:71]
33962 | | | | | `--IDENT -> messageKey [2953:71]
33963 | | | | |--COMMA -> , [2953:81]
33964 | | | | |--EXPR -> EXPR [2954:20]
33965 | | | | | `--IDENT -> FAKE_ARGUMENT_ZERO [2954:20]
33966 | | | | |--COMMA -> , [2954:38]
33967 | | | | |--EXPR -> EXPR [2954:47]
33968 | | | | | `--PLUS -> + [2954:47]
33969 | | | | | |--IDENT -> indent [2954:40]
33970 | | | | | `--IDENT -> indentOffset [2954:49]
33971 | | | | |--COMMA -> , [2954:61]
33972 | | | | `--EXPR -> EXPR [2954:63]
33973 | | | | `--IDENT -> expectedWarning [2954:63]
33974 | | | `--RPAREN -> ) [2954:78]
33975 | | |--SEMI -> ; [2954:79]
33976 | | |--VARIABLE_DEF -> VARIABLE_DEF [2955:12]
33977 | | | |--MODIFIERS -> MODIFIERS [2955:12]
33978 | | | | `--FINAL -> final [2955:12]
33979 | | | |--TYPE -> TYPE [2955:18]
33980 | | | | `--LITERAL_INT -> int [2955:18]
33981 | | | |--IDENT -> indexOfMsgPostfix [2955:22]
33982 | | | `--ASSIGN -> = [2955:40]
33983 | | | `--EXPR -> EXPR [2956:20]
33984 | | | `--PLUS -> + [2956:20]
33985 | | | |--METHOD_CALL -> ( [2955:53]
33986 | | | | |--DOT -> . [2955:45]
33987 | | | | | |--IDENT -> msg [2955:42]
33988 | | | | | `--IDENT -> indexOf [2955:46]
33989 | | | | |--ELIST -> ELIST [2955:54]
33990 | | | | | `--EXPR -> EXPR [2955:54]
33991 | | | | | `--IDENT -> FAKE_ARGUMENT_ZERO [2955:54]
33992 | | | | `--RPAREN -> ) [2955:72]
33993 | | | `--METHOD_CALL -> ( [2956:47]
33994 | | | |--DOT -> . [2956:40]
33995 | | | | |--IDENT -> FAKE_ARGUMENT_ZERO [2956:22]
33996 | | | | `--IDENT -> length [2956:41]
33997 | | | |--ELIST -> ELIST [2956:48]
33998 | | | `--RPAREN -> ) [2956:48]
33999 | | |--SEMI -> ; [2956:49]
34000 | | |--LITERAL_RETURN -> return [2957:12]
34001 | | | |--EXPR -> EXPR [2957:32]
34002 | | | | `--METHOD_CALL -> ( [2957:32]
34003 | | | | |--DOT -> . [2957:22]
34004 | | | | | |--IDENT -> msg [2957:19]
34005 | | | | | `--IDENT -> substring [2957:23]
34006 | | | | |--ELIST -> ELIST [2957:33]
34007 | | | | | `--EXPR -> EXPR [2957:33]
34008 | | | | | `--IDENT -> indexOfMsgPostfix [2957:33]
34009 | | | | `--RPAREN -> ) [2957:50]
34010 | | | `--SEMI -> ; [2957:51]
34011 | | `--RCURLY -> } [2958:8]
34012 | |--METHOD_DEF -> METHOD_DEF [2960:8]
34013 | | |--MODIFIERS -> MODIFIERS [2960:8]
34014 | | | `--LITERAL_PUBLIC -> public [2960:8]
34015 | | |--TYPE -> TYPE [2960:15]
34016 | | | `--LITERAL_INT -> int [2960:15]
34017 | | |--IDENT -> getLineNumber [2960:19]
34018 | | |--LPAREN -> ( [2960:32]
34019 | | |--PARAMETERS -> PARAMETERS [2960:33]
34020 | | |--RPAREN -> ) [2960:33]
34021 | | `--SLIST -> { [2960:35]
34022 | | |--LITERAL_RETURN -> return [2961:12]
34023 | | | |--EXPR -> EXPR [2961:19]
34024 | | | | `--IDENT -> lineNumber [2961:19]
34025 | | | `--SEMI -> ; [2961:29]
34026 | | `--RCURLY -> } [2962:8]
34027 | |--METHOD_DEF -> METHOD_DEF [2964:8]
34028 | | |--MODIFIERS -> MODIFIERS [2964:8]
34029 | | | `--LITERAL_PUBLIC -> public [2964:8]
34030 | | |--TYPE -> TYPE [2964:15]
34031 | | | `--LITERAL_INT -> int [2964:15]
34032 | | |--IDENT -> getIndent [2964:19]
34033 | | |--LPAREN -> ( [2964:28]
34034 | | |--PARAMETERS -> PARAMETERS [2964:29]
34035 | | |--RPAREN -> ) [2964:29]
34036 | | `--SLIST -> { [2964:31]
34037 | | |--LITERAL_RETURN -> return [2965:12]
34038 | | | |--EXPR -> EXPR [2965:19]
34039 | | | | `--IDENT -> indent [2965:19]
34040 | | | `--SEMI -> ; [2965:25]
34041 | | `--RCURLY -> } [2966:8]
34042 | |--METHOD_DEF -> METHOD_DEF [2968:8]
34043 | | |--MODIFIERS -> MODIFIERS [2968:8]
34044 | | | `--LITERAL_PUBLIC -> public [2968:8]
34045 | | |--TYPE -> TYPE [2968:15]
34046 | | | `--LITERAL_INT -> int [2968:15]
34047 | | |--IDENT -> getIndentOffset [2968:19]
34048 | | |--LPAREN -> ( [2968:34]
34049 | | |--PARAMETERS -> PARAMETERS [2968:35]
34050 | | |--RPAREN -> ) [2968:35]
34051 | | `--SLIST -> { [2968:37]
34052 | | |--LITERAL_RETURN -> return [2969:12]
34053 | | | |--EXPR -> EXPR [2969:19]
34054 | | | | `--IDENT -> indentOffset [2969:19]
34055 | | | `--SEMI -> ; [2969:31]
34056 | | `--RCURLY -> } [2970:8]
34057 | |--METHOD_DEF -> METHOD_DEF [2972:8]
34058 | | |--MODIFIERS -> MODIFIERS [2972:8]
34059 | | | `--LITERAL_PUBLIC -> public [2972:8]
34060 | | |--TYPE -> TYPE [2972:15]
34061 | | | `--LITERAL_BOOLEAN -> boolean [2972:15]
34062 | | |--IDENT -> isExpectedNonStrict [2972:23]
34063 | | |--LPAREN -> ( [2972:42]
34064 | | |--PARAMETERS -> PARAMETERS [2972:43]
34065 | | |--RPAREN -> ) [2972:43]
34066 | | `--SLIST -> { [2972:45]
34067 | | |--LITERAL_RETURN -> return [2973:12]
34068 | | | |--EXPR -> EXPR [2973:19]
34069 | | | | `--IDENT -> expectedNonStrict [2973:19]
34070 | | | `--SEMI -> ; [2973:36]
34071 | | `--RCURLY -> } [2974:8]
34072 | |--METHOD_DEF -> METHOD_DEF [2976:8]
34073 | | |--MODIFIERS -> MODIFIERS [2976:8]
34074 | | | `--LITERAL_PUBLIC -> public [2976:8]
34075 | | |--TYPE -> TYPE [2976:15]
34076 | | | `--IDENT -> String [2976:15]
34077 | | |--IDENT -> getExpectedWarning [2976:22]
34078 | | |--LPAREN -> ( [2976:40]
34079 | | |--PARAMETERS -> PARAMETERS [2976:41]
34080 | | |--RPAREN -> ) [2976:41]
34081 | | `--SLIST -> { [2976:43]
34082 | | |--LITERAL_RETURN -> return [2977:12]
34083 | | | |--EXPR -> EXPR [2977:19]
34084 | | | | `--IDENT -> expectedWarning [2977:19]
34085 | | | `--SEMI -> ; [2977:34]
34086 | | `--RCURLY -> } [2978:8]
34087 | |--METHOD_DEF -> METHOD_DEF [2980:8]
34088 | | |--MODIFIERS -> MODIFIERS [2980:8]
34089 | | | `--LITERAL_PUBLIC -> public [2980:8]
34090 | | |--TYPE -> TYPE [2980:15]
34091 | | | `--LITERAL_BOOLEAN -> boolean [2980:15]
34092 | | |--IDENT -> isWarning [2980:23]
34093 | | |--LPAREN -> ( [2980:32]
34094 | | |--PARAMETERS -> PARAMETERS [2980:33]
34095 | | |--RPAREN -> ) [2980:33]
34096 | | `--SLIST -> { [2980:35]
34097 | | |--LITERAL_RETURN -> return [2981:12]
34098 | | | |--EXPR -> EXPR [2981:19]
34099 | | | | `--IDENT -> warning [2981:19]
34100 | | | `--SEMI -> ; [2981:26]
34101 | | `--RCURLY -> } [2982:8]
34102 | `--RCURLY -> } [2984:4]
34103 `--RCURLY -> } [2986:0]